simple-pixi-spine 0.1.0

package/dist/types/packages/base/src/core/ISkeleton.d.ts

@@ -0,0 +1,237 @@
+import { Color, StringMap, Vector2 } from './Utils';
+import type { Matrix } from 'pixi.js';
+/**
+ * @public
+ */
+export declare enum BLEND_MODES {
+    NORMAL = 0,
+    ADD = 1,
+    MULTIPLY = 2,
+    SCREEN = 3
+}
+import type { AttachmentType } from './AttachmentType';
+import type { IAnimation, IEventData } from './IAnimation';
+import type { IIkConstraintData, IPathConstraintData, ITransformConstraintData } from './IConstraint';
+import type { TextureRegion } from './TextureRegion';
+/** Determines how a bone inherits world transforms from parent bones.
+ * @public
+ * */
+export declare enum TransformMode {
+    Normal = 0,
+    OnlyTranslation = 1,
+    NoRotationOrReflection = 2,
+    NoScale = 3,
+    NoScaleOrReflection = 4
+}
+/**
+ * @public
+ */
+export interface IBone {
+    active: boolean;
+    data: IBoneData;
+    matrix?: Matrix;
+}
+/**
+ * @public
+ */
+export interface ISkin {
+    name: string;
+    attachments: Array<StringMap<IAttachment>>;
+    getAttachment(slotIndex: number, name: string): IAttachment | null;
+}
+/**
+ * @public
+ */
+export interface IAttachment {
+    name: string;
+    type: AttachmentType;
+    readonly sequence?: ISequence;
+}
+/**
+ * @public
+ */
+export interface IHasTextureRegion {
+    /** The name used to find the {@link #region()}. */
+    path: string;
+    /** The region used to draw the attachment. After setting the region or if the region's properties are changed,
+     * {@link #updateRegion()} must be called. */
+    region: TextureRegion | null;
+    /** Updates any values the attachment calculates using the {@link #getRegion()}. Must be called after setting the
+     * {@link #getRegion()} or if the region's properties are changed. */
+    /** The color to tint the attachment. */
+    color: Color;
+    readonly sequence: ISequence | null;
+}
+/**
+ * @public
+ */
+export interface ISequence {
+    id: number;
+    regions: TextureRegion[];
+    apply(slot: ISlot, attachment: IHasTextureRegion): void;
+}
+/**
+ * @public
+ */
+export interface IVertexAttachment<Slot extends ISlot = ISlot> extends IAttachment {
+    id: number;
+    computeWorldVerticesOld(slot: Slot, worldVertices: ArrayLike<number>): void;
+    computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
+    worldVerticesLength: number;
+}
+/**
+ * @public
+ */
+export interface IClippingAttachment extends IVertexAttachment {
+    endSlot?: ISlotData;
+}
+/**
+ * @public
+ */
+export interface IRegionAttachment extends IAttachment {
+    region: TextureRegion;
+    color: Color;
+    x: any;
+    y: any;
+    scaleX: any;
+    scaleY: any;
+    rotation: any;
+    width: any;
+    height: number;
+}
+/**
+ * @public
+ */
+export interface IMeshAttachment extends IVertexAttachment {
+    region: TextureRegion;
+    color: Color;
+    regionUVs: Float32Array;
+    triangles: number[];
+    hullLength: number;
+}
+/**
+ * @public
+ */
+export interface ISlotData {
+    index: number;
+    name: string;
+    boneData: IBoneData;
+    color: Color;
+    darkColor: Color;
+    attachmentName: string;
+    blendMode: BLEND_MODES;
+}
+/**
+ * @public
+ */
+export interface IBoneData {
+    index: number;
+    name: string;
+    parent: IBoneData;
+    length: number;
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    shearX: number;
+    shearY: number;
+    transformMode: TransformMode;
+}
+/**
+ * @public
+ */
+export interface ISlot {
+    getAttachment(): IAttachment;
+    data: ISlotData;
+    color: Color;
+    darkColor: Color;
+    blendMode: number;
+    bone: IBone;
+    sprites?: any;
+    currentSprite?: any;
+    currentSpriteName?: string;
+    meshes?: any;
+    currentMesh?: any;
+    currentMeshName?: string;
+    currentMeshId?: number;
+    currentGraphics?: any;
+    clippingContainer?: any;
+    hackRegion?: TextureRegion;
+    hackAttachment?: IAttachment;
+}
+/**
+ * @public
+ */
+export interface ISkeleton<SkeletonData extends ISkeletonData = ISkeletonData, Bone extends IBone = IBone, Slot extends ISlot = ISlot, Skin extends ISkin = ISkin> {
+    bones: Bone[];
+    slots: Slot[];
+    drawOrder: Slot[];
+    skin: Skin;
+    data: SkeletonData;
+    x: number;
+    y: number;
+    updateWorldTransform(physics?: Physics): void;
+    setToSetupPose(): void;
+    findSlotIndex(slotName: string): number;
+    getAttachmentByName(slotName: string, attachmentName: string): IAttachment;
+    setBonesToSetupPose(): void;
+    setSlotsToSetupPose(): void;
+    findBone(boneName: string): Bone;
+    findSlot(slotName: string): Slot;
+    findBoneIndex(boneName: string): number;
+    findSlotIndex(slotName: string): number;
+    setSkinByName(skinName: string): void;
+    setAttachment(slotName: string, attachmentName: string): void;
+    getBounds(offset: Vector2, size: Vector2, temp: Array<number>): void;
+}
+/**
+ * @public
+ */
+export interface ISkeletonParser {
+    scale: number;
+}
+/**
+ * @public
+ */
+export interface ISkeletonData<BoneData extends IBoneData = IBoneData, SlotData extends ISlotData = ISlotData, Skin extends ISkin = ISkin, Animation extends IAnimation = IAnimation, EventData extends IEventData = IEventData, IkConstraintData extends IIkConstraintData = IIkConstraintData, TransformConstraintData extends ITransformConstraintData = ITransformConstraintData, PathConstraintData extends IPathConstraintData = IPathConstraintData> {
+    [x: string]: any;
+    name: string;
+    bones: BoneData[];
+    slots: SlotData[];
+    skins: Skin[];
+    defaultSkin: Skin;
+    events: EventData[];
+    animations: Animation[];
+    version: string;
+    hash: string;
+    width: number;
+    height: number;
+    ikConstraints: IkConstraintData[];
+    transformConstraints: TransformConstraintData[];
+    pathConstraints: PathConstraintData[];
+    findBone(boneName: string): BoneData | null;
+    findBoneIndex(boneName: string): number;
+    findSlot(slotName: string): SlotData | null;
+    findSlotIndex(slotName: string): number;
+    findSkin(skinName: string): Skin | null;
+    findEvent(eventDataName: string): EventData | null;
+    findAnimation(animationName: string): Animation | null;
+    findIkConstraint(constraintName: string): IkConstraintData | null;
+    findTransformConstraint(constraintName: string): TransformConstraintData | null;
+    findPathConstraint(constraintName: string): PathConstraintData | null;
+}
+/** Determines how physics and other non-deterministic updates are applied. */
+/**
+ * @public
+ */
+export declare enum Physics {
+    /** Physics are not updated or applied. */
+    none = 0,
+    /** Physics are reset to the current pose. */
+    reset = 1,
+    /** Physics are updated and the pose from physics is applied. */
+    update = 2,
+    /** Physics are not updated but the pose from physics is applied. */
+    pose = 3
+}

package/dist/types/packages/base/src/core/SkeletonBoundsBase.d.ts

@@ -0,0 +1,51 @@
+import type { ISkeleton, IVertexAttachment } from './ISkeleton';
+import { NumberArrayLike } from './Utils';
+/** Collects each visible BoundingBoxAttachment and computes the world vertices for its polygon. The polygon vertices are
+ * provided along with convenience methods for doing hit detection.
+ * @public
+ * */
+export declare class SkeletonBoundsBase<BoundingBoxAttachment extends IVertexAttachment> {
+    /** The left edge of the axis aligned bounding box. */
+    minX: number;
+    /** The bottom edge of the axis aligned bounding box. */
+    minY: number;
+    /** The right edge of the axis aligned bounding box. */
+    maxX: number;
+    /** The top edge of the axis aligned bounding box. */
+    maxY: number;
+    /** The visible bounding boxes. */
+    boundingBoxes: BoundingBoxAttachment[];
+    /** The world vertices for the bounding box polygons. */
+    polygons: NumberArrayLike[];
+    private polygonPool;
+    /** Clears any previous polygons, finds all visible bounding box attachments, and computes the world vertices for each bounding
+     * box's polygon.
+     * @param updateAabb If true, the axis aligned bounding box containing all the polygons is computed. If false, the
+     *           SkeletonBounds AABB methods will always return true. */
+    update(skeleton: ISkeleton, updateAabb: boolean): void;
+    aabbCompute(): void;
+    /** Returns true if the axis aligned bounding box contains the point. */
+    aabbContainsPoint(x: number, y: number): boolean;
+    /** Returns true if the axis aligned bounding box intersects the line segment. */
+    aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean;
+    /** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
+    aabbIntersectsSkeleton(bounds: SkeletonBoundsBase<BoundingBoxAttachment>): boolean;
+    /** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
+     * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true.
+     * Cannot be done here because BoundingBoxAttachment is not a thing yet*/
+    containsPoint(x: number, y: number): BoundingBoxAttachment | null;
+    /** Returns true if the polygon contains the point. */
+    containsPointPolygon(polygon: NumberArrayLike, x: number, y: number): boolean;
+    /** Returns the first bounding box attachment that contains any part of the line segment, or null. When doing many checks, it
+     * is usually more efficient to only call this method if {@link #aabbIntersectsSegment()} returns
+     * true. */
+    intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment;
+    /** Returns true if the polygon contains any part of the line segment. */
+    intersectsSegmentPolygon(polygon: NumberArrayLike, x1: number, y1: number, x2: number, y2: number): boolean;
+    /** Returns the polygon for the specified bounding box, or null. */
+    getPolygon(boundingBox: BoundingBoxAttachment): NumberArrayLike;
+    /** The width of the axis aligned bounding box. */
+    getWidth(): number;
+    /** The height of the axis aligned bounding box. */
+    getHeight(): number;
+}

package/dist/types/packages/base/src/core/TextureAtlas.d.ts

@@ -0,0 +1,41 @@
+import { Texture } from 'pixi.js';
+import { TextureFilter, TextureRegion, TextureWrap } from './TextureRegion';
+import type { TextureSource as BaseTexture } from 'pixi.js';
+import type { Disposable, StringMap } from './Utils';
+/**
+ * @public
+ */
+export declare class TextureAtlas implements Disposable {
+    pages: TextureAtlasPage[];
+    regions: TextureAtlasRegion[];
+    constructor(atlasText?: string, textureLoader?: (path: string, loaderFunction: (tex: BaseTexture) => any) => any, callback?: (obj: TextureAtlas) => any);
+    addTexture(name: string, texture: Texture): TextureAtlasRegion;
+    addTextureHash(textures: StringMap<Texture>, stripExtension: boolean): void;
+    addSpineAtlas(atlasText: string, textureLoader: (path: string, loaderFunction: (tex: BaseTexture) => any) => any, callback: (obj: TextureAtlas) => any): void;
+    private load;
+    findRegion(name: string): TextureAtlasRegion;
+    dispose(): void;
+}
+/**
+ * @public
+ */
+export declare class TextureAtlasPage {
+    name: string;
+    minFilter: TextureFilter;
+    magFilter: TextureFilter;
+    uWrap: TextureWrap;
+    vWrap: TextureWrap;
+    baseTexture: BaseTexture;
+    width: number;
+    height: number;
+    pma: boolean;
+    setFilters(): void;
+}
+/**
+ * @public
+ */
+export declare class TextureAtlasRegion extends TextureRegion {
+    page: TextureAtlasPage;
+    name: string;
+    index: number;
+}

package/dist/types/packages/base/src/core/TextureRegion.d.ts

@@ -0,0 +1,55 @@
+import type { Texture, Rectangle } from 'pixi.js';
+/**
+ * @public
+ */
+export declare function filterFromString(text: string): TextureFilter;
+/**
+ * @public
+ */
+export declare function wrapFromString(text: string): TextureWrap;
+/**
+ * @public
+ */
+export declare enum TextureFilter {
+    Nearest = 9728,// WebGLRenderingContext.NEAREST
+    Linear = 9729,// WebGLRenderingContext.LINEAR
+    MipMap = 9987,// WebGLRenderingContext.LINEAR_MIPMAP_LINEAR
+    MipMapNearestNearest = 9984,// WebGLRenderingContext.NEAREST_MIPMAP_NEAREST
+    MipMapLinearNearest = 9985,// WebGLRenderingContext.LINEAR_MIPMAP_NEAREST
+    MipMapNearestLinear = 9986,// WebGLRenderingContext.NEAREST_MIPMAP_LINEAR
+    MipMapLinearLinear = 9987
+}
+/**
+ * @public
+ */
+export declare enum TextureWrap {
+    MirroredRepeat = 33648,// WebGLRenderingContext.MIRRORED_REPEAT
+    ClampToEdge = 33071,// WebGLRenderingContext.CLAMP_TO_EDGE
+    Repeat = 10497
+}
+/**
+ * @public
+ */
+export declare class TextureRegion {
+    texture: Texture;
+    size: Rectangle;
+    names: string[];
+    values: number[][];
+    renderObject: any;
+    get width(): number;
+    get height(): number;
+    get u(): number;
+    get v(): number;
+    get u2(): number;
+    get v2(): number;
+    get offsetX(): number;
+    get offsetY(): number;
+    get pixiOffsetY(): number;
+    get spineOffsetY(): number;
+    get originalWidth(): number;
+    get originalHeight(): number;
+    get x(): number;
+    get y(): number;
+    get rotate(): boolean;
+    get degrees(): number;
+}

package/dist/types/packages/base/src/core/Utils.d.ts

@@ -0,0 +1,198 @@
+import type { ISkeleton } from './ISkeleton';
+/**
+ * @public
+ */
+export interface StringMap<T> {
+    [key: string]: T;
+}
+/**
+ * @public
+ */
+export declare class IntSet {
+    array: number[];
+    add(value: number): boolean;
+    contains(value: number): boolean;
+    remove(value: number): void;
+    clear(): void;
+}
+/**
+ * @public
+ */
+export declare class StringSet {
+    entries: StringMap<boolean>;
+    size: number;
+    add(value: string): boolean;
+    addAll(values: string[]): boolean;
+    contains(value: string): boolean;
+    clear(): void;
+}
+/**
+ * @public
+ */
+export interface NumberArrayLike {
+    readonly length: number;
+    [n: number]: number;
+}
+/**
+ * @public
+ */
+export type IntArrayLike = Array<number> | Int16Array;
+/**
+ * @public
+ */
+export interface Disposable {
+    dispose(): void;
+}
+/**
+ * @public
+ */
+export interface Restorable {
+    restore(): void;
+}
+/**
+ * @public
+ */
+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;
+    static fromString(hex: string): Color;
+}
+/**
+ * @public
+ */
+export declare class MathUtils {
+    static PI: number;
+    static PI2: number;
+    static invPI2: 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 atan2Deg(y: number, x: 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;
+    static isPowerOfTwo(value: number): boolean;
+}
+/**
+ * @public
+ */
+export declare abstract class Interpolation {
+    protected abstract applyInternal(a: number): number;
+    apply(start: number, end: number, a: number): number;
+}
+/**
+ * @public
+ */
+export declare class Pow extends Interpolation {
+    protected power: number;
+    constructor(power: number);
+    applyInternal(a: number): number;
+}
+/**
+ * @public
+ */
+export declare class PowOut extends Pow {
+    applyInternal(a: number): number;
+}
+/**
+ * @public
+ */
+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 arrayFill<T>(array: ArrayLike<T>, fromIndex: number, toIndex: number, value: T): 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): NumberArrayLike;
+    static newShortArray(size: number): IntArrayLike;
+    static toFloatArray(array: Array<number>): number[] | Float32Array;
+    static toSinglePrecision(value: number): number;
+    static webkit602BugfixHelper(alpha: number, blend: any): void;
+    static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
+    static enumValue(type: any, name: string): any;
+}
+/**
+ * @public
+ */
+export declare class DebugUtils {
+    static logBones(skeleton: ISkeleton): void;
+}
+/**
+ * @public
+ */
+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;
+}
+/**
+ * @public
+ */
+export declare class Vector2 {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    set(x: number, y: number): Vector2;
+    length(): number;
+    normalize(): this;
+}
+/**
+ * @public
+ */
+export declare class TimeKeeper {
+    maxDelta: number;
+    framesPerSecond: number;
+    delta: number;
+    totalTime: number;
+    private lastTime;
+    private frameCount;
+    private frameTime;
+    update(): void;
+}
+/**
+ * @public
+ */
+export interface ArrayLike<T> {
+    length: number;
+    [n: number]: T;
+}
+/**
+ * @public
+ */
+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/dist/types/packages/base/src/core/versions.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @public
+ */
+export declare enum SPINE_VERSION {
+    UNKNOWN = 0,
+    VER37 = 37,
+    VER38 = 38,
+    VER40 = 40,
+    VER41 = 41,
+    VER42 = 42
+}
+/**
+ * @public
+ */
+export declare function detectSpineVersion(version: string): SPINE_VERSION;

package/dist/types/packages/base/src/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="packages/base/global" />
+export * from './core/AttachmentType';
+export * from './core/BinaryInput';
+export * from './core/IAnimation';
+export * from './core/IConstraint';
+export * from './core/ISkeleton';
+export * from './core/SkeletonBoundsBase';
+export * from './core/TextureAtlas';
+export * from './core/TextureRegion';
+export * from './core/Utils';
+export * from './core/versions';
+export * from './settings';
+export * from './SpineBase';
+export * from './SpineDebugRenderer';

package/dist/types/packages/base/src/settings.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @public
+ */
+export declare const settings: {
+    yDown: boolean;
+    /**
+     * pixi-spine gives option to not fail at certain parsing errors
+     * spine-ts fails here
+     */
+    FAIL_ON_NON_EXISTING_SKIN: boolean;
+    /**
+     * past Spine.globalAutoUpdate
+     */
+    GLOBAL_AUTO_UPDATE: boolean;
+    /**
+     * past Spine.globalDelayLimit
+     */
+    GLOBAL_DELAY_LIMIT: number;
+};

package/dist/types/packages/loader-3.8/src/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="packages/loader-3.8/global" />
+import '@pixi-spine/loader-base';

package/dist/types/packages/loader-4.0/src/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="packages/loader-4.0/global" />
+import '@pixi-spine/loader-base';

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

@@ -0,0 +1,2 @@
+/// <reference types="packages/loader-4.1/global" />
+import '@pixi-spine/loader-base';

package/dist/types/packages/loader-4.2/src/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="packages/loader-4.2/global" />
+import '@pixi-spine/loader-base';

package/dist/types/packages/loader-base/src/SpineLoaderAbstract.d.ts

@@ -0,0 +1,36 @@
+import { Texture, Loader, TextureSource as BaseTexture } from 'pixi.js';
+import { ISkeletonData, ISkeletonParser, TextureAtlas } from '@pixi-spine/base';
+/**
+ * This abstract class is used to create a spine loader specifically for a needed version
+ * @public
+ */
+export declare abstract class SpineLoaderAbstract<SKD extends ISkeletonData> {
+    constructor();
+    abstract createJsonParser(): ISkeletonParser;
+    abstract createBinaryParser(): ISkeletonParser;
+    abstract parseData(parser: ISkeletonParser, atlas: TextureAtlas, dataToParse: any): ISpineResource<SKD>;
+    installLoader(): any;
+}
+/**
+ * The final spineData+spineAtlas object that can be used to create a Spine.
+ * @public
+ */
+export interface ISpineResource<SKD extends ISkeletonData> {
+    spineData: SKD;
+    spineAtlas: TextureAtlas;
+}
+/**
+ * Metadata for loading spine assets
+ * @public
+ */
+export interface ISpineMetadata {
+    spineSkeletonScale?: number;
+    spineAtlas?: Partial<TextureAtlas>;
+    spineAtlasAlias?: string[];
+    spineAtlasFile?: string;
+    atlasRawData?: string;
+    imageLoader?: (loader: Loader, path: string) => (path: string, callback: (tex: BaseTexture) => any) => any;
+    imageMetadata?: any;
+    images?: Record<string, Texture | BaseTexture>;
+    image?: Texture | BaseTexture;
+}

package/dist/types/packages/loader-base/src/atlasLoader.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Ugly function to promisify the spine texture atlas loader function.
+ * @public
+ */
+export declare const makeSpineTextureAtlasLoaderFunctionFromPixiLoaderObject: (loader: any, atlasBasePath: string, imageMetadata: any) => (pageName: string, textureLoadedCallback: (tex: any) => any) => Promise<void>;