simple-pixi-spine 0.1.0

package/dist/types/packages/runtime-4.1/src/core/attachments/Attachment.d.ts

@@ -0,0 +1,53 @@
+import { AttachmentType } from '@pixi-spine/base';
+import type { IAttachment, NumberArrayLike } from '@pixi-spine/base';
+import type { Slot } from '../Slot';
+/**
+ * The base class for all attachments.
+ * @public
+ */
+export declare abstract class Attachment implements IAttachment {
+    name: string;
+    type: AttachmentType;
+    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}.
+ * @public
+ */
+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> | null;
+    /** 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: NumberArrayLike;
+    /** The maximum number of world vertex values that can be output by
+     * {@link #computeWorldVertices()} using the `count` parameter. */
+    worldVerticesLength: number;
+    /** Timelines for the timeline attachment are also applied to this attachment.
+     * May be null if no attachment-specific timelines should be applied. */
+    timelineAttachment: Attachment;
+    constructor(name: string);
+    computeWorldVerticesOld(slot: Slot, worldVertices: ArrayLike<number>): void;
+    /** 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: NumberArrayLike, offset: number, stride: number): void;
+    /** Does not copy id (generated) or name (set on construction). **/
+    copyTo(attachment: VertexAttachment): void;
+}

package/dist/types/packages/runtime-4.1/src/core/attachments/AttachmentLoader.d.ts

@@ -0,0 +1,25 @@
+import type { Skin } from '../Skin';
+import type { RegionAttachment } from './RegionAttachment';
+import type { MeshAttachment } from './MeshAttachment';
+import type { BoundingBoxAttachment } from './BoundingBoxAttachment';
+import type { PathAttachment } from './PathAttachment';
+import type { PointAttachment } from './PointAttachment';
+import type { ClippingAttachment } from './ClippingAttachment';
+import type { Sequence } from './Sequence';
+/**
+ * @public
+ */
+export interface AttachmentLoader {
+    /** @return May be null to not load an attachment. */
+    newRegionAttachment(skin: Skin, name: string, path: string, sequence: Sequence | null): RegionAttachment;
+    /** @return May be null to not load an attachment. */
+    newMeshAttachment(skin: Skin, name: string, path: string, sequence: Sequence | null): 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/dist/types/packages/runtime-4.1/src/core/attachments/BoundingBoxAttachment.d.ts

@@ -0,0 +1,11 @@
+import { Attachment, VertexAttachment } from './Attachment';
+import { AttachmentType, Color } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class BoundingBoxAttachment extends VertexAttachment {
+    type: AttachmentType;
+    color: Color;
+    constructor(name: string);
+    copy(): Attachment;
+}

package/dist/types/packages/runtime-4.1/src/core/attachments/ClippingAttachment.d.ts

@@ -0,0 +1,17 @@
+import { Attachment, VertexAttachment } from './Attachment';
+import { AttachmentType, Color, IClippingAttachment } from '@pixi-spine/base';
+import type { SlotData } from '../SlotData';
+/**
+ * @public
+ */
+export declare class ClippingAttachment extends VertexAttachment implements IClippingAttachment {
+    type: AttachmentType;
+    /** 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 | null;
+    /** 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/dist/types/packages/runtime-4.1/src/core/attachments/MeshAttachment.d.ts

@@ -0,0 +1,42 @@
+import { Attachment, VertexAttachment } from './Attachment';
+import { AttachmentType, Color, IMeshAttachment, IHasTextureRegion, NumberArrayLike, TextureRegion } from '@pixi-spine/base';
+import type { Sequence } from './Sequence';
+import type { Slot } from '../Slot';
+/**
+ * @public
+ */
+export declare class MeshAttachment extends VertexAttachment implements IMeshAttachment, IHasTextureRegion {
+    type: AttachmentType;
+    region: TextureRegion | null;
+    /** The name of the texture region for this attachment. */
+    path: string;
+    /** The UV pair for each vertex, normalized within the texture region. */
+    regionUVs: Float32Array;
+    /** 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;
+    sequence: Sequence | null;
+    tempColor: Color;
+    constructor(name: string, path: string);
+    /** 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;
+    computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: NumberArrayLike, offset: number, stride: number): void;
+    /** Returns a new mesh with the {@link #parentMesh} set to this mesh's parent mesh, if any, else to this mesh. **/
+    newLinkedMesh(): MeshAttachment;
+}

package/dist/types/packages/runtime-4.1/src/core/attachments/PathAttachment.d.ts

@@ -0,0 +1,20 @@
+import { Attachment, VertexAttachment } from './Attachment';
+import { AttachmentType, Color } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class PathAttachment extends VertexAttachment {
+    type: AttachmentType;
+    /** 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/dist/types/packages/runtime-4.1/src/core/attachments/PointAttachment.d.ts

@@ -0,0 +1,19 @@
+import { Attachment, VertexAttachment } from './Attachment';
+import { AttachmentType, Color, Vector2 } from '@pixi-spine/base';
+import type { Bone } from '../Bone';
+/**
+ * @public
+ */
+export declare class PointAttachment extends VertexAttachment {
+    type: AttachmentType;
+    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/dist/types/packages/runtime-4.1/src/core/attachments/RegionAttachment.d.ts

@@ -0,0 +1,82 @@
+import { Attachment } from './Attachment';
+import { AttachmentType, NumberArrayLike, Color, TextureRegion, IHasTextureRegion, IRegionAttachment } from '@pixi-spine/base';
+import type { Sequence } from './Sequence';
+import type { Slot } from '../Slot';
+/**
+ * @public
+ */
+export declare class RegionAttachment extends Attachment implements IRegionAttachment, IHasTextureRegion {
+    type: AttachmentType;
+    /** 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;
+    private rendererObject;
+    region: TextureRegion | null;
+    sequence: Sequence | null;
+    /** 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: NumberArrayLike;
+    uvs: NumberArrayLike;
+    tempColor: Color;
+    constructor(name: string, path: string);
+    /** Calculates the {@link #offset} using the region settings. Must be called after changing region settings. */
+    updateRegion(): void;
+    /** Transforms the attachment's four vertices to world coordinates. If the attachment has a {@link #sequence}, the region may
+     * be changed.
+     * <p>
+     * See <a href="http://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
+     * Runtimes Guide.
+     * @param worldVertices The output world vertices. Must have a length >= <code>offset</code> + 8.
+     * @param offset The <code>worldVertices</code> index to begin writing values.
+     * @param stride The number of <code>worldVertices</code> entries between the value pairs written. */
+    computeWorldVertices(slot: Slot, worldVertices: NumberArrayLike, offset: number, stride: number): void;
+    copy(): Attachment;
+    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;
+}

package/dist/types/packages/runtime-4.1/src/core/attachments/Sequence.d.ts

@@ -0,0 +1,35 @@
+import { TextureRegion, IHasTextureRegion, ISequence } from '@pixi-spine/base';
+import type { Slot } from '../Slot';
+/**
+ * @public
+ */
+export declare class Sequence implements ISequence {
+    private static _nextID;
+    id: number;
+    regions: TextureRegion[];
+    start: number;
+    digits: number;
+    /** The index of the region to show for the setup pose. */
+    setupIndex: number;
+    constructor(count: number);
+    copy(): Sequence;
+    apply(slot: Slot, attachment: IHasTextureRegion): void;
+    getPath(basePath: string, index: number): string;
+    private static nextID;
+}
+/**
+ * @public
+ */
+export declare enum SequenceMode {
+    hold = 0,
+    once = 1,
+    loop = 2,
+    pingpong = 3,
+    onceReverse = 4,
+    loopReverse = 5,
+    pingpongReverse = 6
+}
+/**
+ * @public
+ */
+export declare const SequenceModeValues: SequenceMode[];

package/dist/types/packages/runtime-4.1/src/core/attachments/index.d.ts

@@ -0,0 +1,9 @@
+export * from './Attachment';
+export * from './AttachmentLoader';
+export * from './BoundingBoxAttachment';
+export * from './ClippingAttachment';
+export * from './MeshAttachment';
+export * from './PathAttachment';
+export * from './PointAttachment';
+export * from './RegionAttachment';
+export * from './Sequence';

package/dist/types/packages/runtime-4.1/src/index.d.ts

@@ -0,0 +1,26 @@
+export * from './core/attachments';
+export * from './core/Animation';
+export * from './core/AnimationState';
+export * from './core/AnimationStateData';
+export * from './core/AtlasAttachmentLoader';
+export * from './core/Bone';
+export * from './core/BoneData';
+export * from './core/ConstraintData';
+export * from './core/Event';
+export * from './core/EventData';
+export * from './core/IkConstraint';
+export * from './core/IkConstraintData';
+export * from './core/PathConstraint';
+export * from './core/PathConstraintData';
+export * from './core/Skeleton';
+export * from './core/SkeletonBinary';
+export * from './core/SkeletonBounds';
+export * from './core/SkeletonData';
+export * from './core/SkeletonJson';
+export * from './core/Skin';
+export * from './core/Slot';
+export * from './core/SlotData';
+export * from './core/TransformConstraint';
+export * from './core/TransformConstraintData';
+export * from './core/Updatable';
+export * from './Spine';

package/dist/types/packages/runtime-4.2/src/Spine.d.ts

@@ -0,0 +1,11 @@
+import { AnimationState } from './core/AnimationState';
+import { AnimationStateData } from './core/AnimationStateData';
+import { Skeleton } from './core/Skeleton';
+import { SpineBase } from '@pixi-spine/base';
+import type { SkeletonData } from './core/SkeletonData';
+/**
+ * @public
+ */
+export declare class Spine extends SpineBase<Skeleton, SkeletonData, AnimationState, AnimationStateData> {
+    createSkeleton(spineData: SkeletonData): void;
+}