simple-pixi-spine 0.1.0

package/dist/types/build.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/types/bundles/pixi-spine/rollup.config.d.mts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/types/bundles/pixi-spine/src/index.d.ts

@@ -0,0 +1,5 @@
+import '@pixi-spine/loader-uni';
+import { Spine, spine38, spine40, spine41, spine42 } from '@pixi-spine/loader-uni';
+export { Spine, spine38, spine40, spine41, spine42 };
+export * from '@pixi-spine/base';
+export { SkeletonBounds } from '@pixi-spine/runtime-4.1';

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

@@ -0,0 +1,167 @@
+import { Rectangle, Texture, Container, Graphics, MeshSimple as SimpleMesh, Sprite, Ticker } from 'pixi.js';
+import { TextureRegion } from './core/TextureRegion';
+import type { IAnimationState, IAnimationStateData } from './core/IAnimation';
+import type { IAttachment, IClippingAttachment, IMeshAttachment, IRegionAttachment, ISkeleton, ISkeletonData, ISlot } from './core/ISkeleton';
+import type { ISpineDebugRenderer } from './SpineDebugRenderer';
+/**
+ * @public
+ */
+export interface ISpineDisplayObject extends Container {
+    region?: TextureRegion;
+    attachment?: IAttachment;
+}
+/**
+ * @public
+ */
+export declare class SpineSprite extends Sprite implements ISpineDisplayObject {
+    region?: TextureRegion;
+    attachment?: IAttachment;
+}
+/**
+ * @public
+ */
+export declare class SpineMesh extends SimpleMesh implements ISpineDisplayObject {
+    region?: TextureRegion;
+    attachment?: IAttachment;
+    constructor(texture: Texture, vertices?: Float32Array, uvs?: Float32Array, indices?: Uint16Array, drawMode?: number);
+}
+/**
+ * A class that enables the you to import and run your spine animations in pixi.
+ * The Spine animation data needs to be loaded using either the Loader or a SpineLoader before it can be used by this class
+ * See example 12 (http://www.goodboydigital.com/pixijs/examples/12/) to see a working example and check out the source
+ *
+ * ```js
+ * let spineAnimation = new spine(spineData);
+ * ```
+ *
+ * @public
+ * @class
+ * @extends Container
+ * @memberof spine
+ * @param spineData {object} The spine data loaded from a spine atlas.
+ */
+export declare abstract class SpineBase<Skeleton extends ISkeleton, SkeletonData extends ISkeletonData, AnimationState extends IAnimationState, AnimationStateData extends IAnimationStateData> extends Container implements GlobalMixins.Spine {
+    tintRgb: ArrayLike<number>;
+    spineData: SkeletonData;
+    skeleton: Skeleton;
+    stateData: AnimationStateData;
+    state: AnimationState;
+    slotContainers: Array<Container>;
+    tempClipContainers: Array<Container>;
+    localDelayLimit: number;
+    private _autoUpdate;
+    protected _visible: boolean;
+    private _debug;
+    get debug(): ISpineDebugRenderer;
+    set debug(value: ISpineDebugRenderer);
+    abstract createSkeleton(spineData: ISkeletonData): any;
+    constructor(spineData: SkeletonData);
+    /**
+     * If this flag is set to true, the spine animation will be automatically updated every
+     * time the object id drawn. The down side of this approach is that the delta time is
+     * automatically calculated and you could miss out on cool effects like slow motion,
+     * pause, skip ahead and the sorts. Most of these effects can be achieved even with
+     * autoUpdate enabled but are harder to achieve.
+     *
+     * @member {boolean}
+     * @memberof spine.Spine#
+     * @default true
+     */
+    get autoUpdate(): boolean;
+    set autoUpdate(value: boolean);
+    /**
+     * The tint applied to the spine object. This is a hex value. A value of 0xFFFFFF will remove any tint effect.
+     *
+     * @member {number}
+     * @memberof spine.Spine#
+     * @default 0xFFFFFF
+     */
+    get tint(): number;
+    set tint(value: number);
+    /**
+     * Limit value for the update dt with Spine.globalDelayLimit
+     * that can be overridden with localDelayLimit
+     * @return {number} - Maximum processed dt value for the update
+     */
+    get delayLimit(): number;
+    /**
+     * Update the spine skeleton and its animations by delta time (dt)
+     *
+     * @param dt {number} Delta time. Time by which the animation should be updated
+     */
+    update(dt: number): void;
+    private setSpriteRegion;
+    private setMeshRegion;
+    /**
+     * When autoupdate is set to yes this function is used as pixi's updateTransform function
+     *
+     * @private
+     */
+    autoUpdateTransform(ticker: Ticker): void;
+    /**
+     * Create a new sprite to be used with core.RegionAttachment
+     *
+     * @param slot {spine.Slot} The slot to which the attachment is parented
+     * @param attachment {spine.RegionAttachment} The attachment that the sprite will represent
+     * @private
+     */
+    createSprite(slot: ISlot, attachment: IRegionAttachment, defName: string): SpineSprite;
+    /**
+     * Creates a Strip from the spine data
+     * @param slot {spine.Slot} The slot to which the attachment is parented
+     * @param attachment {spine.RegionAttachment} The attachment that the sprite will represent
+     * @private
+     */
+    createMesh(slot: ISlot, attachment: IMeshAttachment): SpineMesh;
+    static clippingPolygon: Array<number>;
+    private tempVertices;
+    createGraphics(slot: ISlot, clip: IClippingAttachment): Graphics;
+    updateGraphics(slot: ISlot, clip: IClippingAttachment): void;
+    /**
+     * Changes texture in attachment in specific slot.
+     *
+     * PIXI runtime feature, it was made to satisfy our users.
+     *
+     * @param slotIndex {number}
+     * @param [texture = null] {PIXI.Texture} If null, take default (original) texture
+     * @param [size = null] {PIXI.Point} sometimes we need new size for region attachment, you can pass 'texture.orig' there
+     * @returns {boolean} Success flag
+     */
+    hackTextureBySlotIndex(slotIndex: number, texture?: Texture, size?: Rectangle): boolean;
+    /**
+     * Changes texture in attachment in specific slot.
+     *
+     * PIXI runtime feature, it was made to satisfy our users.
+     *
+     * @param slotName {string}
+     * @param [texture = null] {PIXI.Texture} If null, take default (original) texture
+     * @param [size = null] {PIXI.Point} sometimes we need new size for region attachment, you can pass 'texture.orig' there
+     * @returns {boolean} Success flag
+     */
+    hackTextureBySlotName(slotName: string, texture?: Texture, size?: Rectangle): boolean;
+    /**
+     * Changes texture of an attachment
+     *
+     * PIXI runtime feature, it was made to satisfy our users.
+     *
+     * @param slotName {string}
+     * @param attachmentName {string}
+     * @param [texture = null] {PIXI.Texture} If null, take default (original) texture
+     * @param [size = null] {PIXI.Point} sometimes we need new size for region attachment, you can pass 'texture.orig' there
+     * @returns {boolean} Success flag
+     */
+    hackTextureAttachment(slotName: string, attachmentName: string, texture: any, size?: Rectangle): boolean;
+    newContainer(): Container<import("pixi.js").ContainerChild>;
+    newSprite(tex: Texture): SpineSprite;
+    newGraphics(): Graphics;
+    newMesh(texture: Texture, vertices?: Float32Array, uvs?: Float32Array, indices?: Uint16Array, drawMode?: number): SpineMesh;
+    transformHack(): number;
+    /**
+     * Hack for pixi-display and pixi-lights. Every attachment name ending with a suffix will be added to different layer
+     * @param nameSuffix
+     * @param group
+     * @param outGroup
+     */
+    hackAttachmentGroups(nameSuffix: string, group: any, outGroup: any): any[][];
+    destroy(options?: any): void;
+}

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

@@ -0,0 +1,60 @@
+import type { IAnimationState, IAnimationStateData } from './core/IAnimation';
+import type { ISkeleton, ISkeletonData } from './core/ISkeleton';
+import type { SpineBase } from './SpineBase';
+/**
+ * Make a class that extends from this interface to create your own debug renderer.
+ * @public
+ */
+export interface ISpineDebugRenderer {
+    /**
+     * This will be called every frame, after the spine has been updated.
+     */
+    renderDebug(spine: SpineBase<ISkeleton, ISkeletonData, IAnimationState, IAnimationStateData>): void;
+    /**
+     *  This is called when the `spine.debug` object is set to null or when the spine is destroyed.
+     */
+    unregisterSpine(spine: SpineBase<ISkeleton, ISkeletonData, IAnimationState, IAnimationStateData>): void;
+    /**
+     * This is called when the `spine.debug` object is set to a new instance of a debug renderer.
+     */
+    registerSpine(spine: SpineBase<ISkeleton, ISkeletonData, IAnimationState, IAnimationStateData>): void;
+}
+/**
+ * This is a debug renderer that uses PixiJS Graphics under the hood.
+ * @public
+ */
+export declare class SpineDebugRenderer implements ISpineDebugRenderer {
+    private registeredSpines;
+    drawDebug: boolean;
+    drawMeshHull: boolean;
+    drawMeshTriangles: boolean;
+    drawBones: boolean;
+    drawPaths: boolean;
+    drawBoundingBoxes: boolean;
+    drawClipping: boolean;
+    drawRegionAttachments: boolean;
+    lineWidth: number;
+    regionAttachmentsColor: number;
+    meshHullColor: number;
+    meshTrianglesColor: number;
+    clippingPolygonColor: number;
+    boundingBoxesRectColor: number;
+    boundingBoxesPolygonColor: number;
+    boundingBoxesCircleColor: number;
+    pathsCurveColor: number;
+    pathsLineColor: number;
+    skeletonXYColor: number;
+    bonesColor: number;
+    /**
+     * The debug is attached by force to each spine object. So we need to create it inside the spine when we get the first update
+     */
+    registerSpine(spine: SpineBase<ISkeleton, ISkeletonData, IAnimationState, IAnimationStateData>): void;
+    renderDebug(spine: SpineBase<ISkeleton, ISkeletonData, IAnimationState, IAnimationStateData>): void;
+    private drawBonesFunc;
+    private drawRegionAttachmentsFunc;
+    private drawMeshHullAndMeshTriangles;
+    private drawClippingFunc;
+    private drawBoundingBoxesFunc;
+    private drawPathsFunc;
+    unregisterSpine(spine: SpineBase<ISkeleton, ISkeletonData, IAnimationState, IAnimationStateData>): void;
+}

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * @public
+ */
+export declare class BinaryInput {
+    strings: string[];
+    private index;
+    private buffer;
+    constructor(data: Uint8Array, strings?: string[], index?: number, buffer?: DataView);
+    readByte(): number;
+    readUnsignedByte(): number;
+    readShort(): number;
+    readInt32(): number;
+    readInt(optimizePositive: boolean): number;
+    readStringRef(): string | null;
+    readString(): string | null;
+    readFloat(): number;
+    readBoolean(): boolean;
+}

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

@@ -0,0 +1,131 @@
+import type { ISkeleton, ISkeletonData } from './ISkeleton';
+import type { StringMap } from './Utils';
+/** Controls how a timeline value is mixed with the setup pose value or current pose value when a timeline's `alpha`
+ * < 1.
+ *
+ * See Timeline {@link Timeline#apply(Skeleton, float, float, Array, float, MixBlend, MixDirection)}.
+ * @public
+ * */
+export declare enum MixBlend {
+    /** Transitions from the setup value to the timeline value (the current value is not used). Before the first key, the setup
+     * value is set. */
+    setup = 0,
+    /** Transitions from the current value to the timeline value. Before the first key, transitions from the current value to
+     * the setup value. Timelines which perform instant transitions, such as DrawOrderTimeline or
+     * AttachmentTimeline, use the setup value before the first key.
+     *
+     * `first` is intended for the first animations applied, not for animations layered on top of those. */
+    first = 1,
+    /** Transitions from the current value to the timeline value. No change is made before the first key (the current value is
+     * kept until the first key).
+     *
+     * `replace` is intended for animations layered on top of others, not for the first animations applied. */
+    replace = 2,
+    /** Transitions from the current value to the current value plus the timeline value. No change is made before the first key
+     * (the current value is kept until the first key).
+     *
+     * `add` is intended for animations layered on top of others, not for the first animations applied. Properties
+     * keyed by additive animations must be set manually or by another animation before applying the additive animations, else
+     * the property values will increase continually. */
+    add = 3
+}
+/** Indicates whether a timeline's `alpha` is mixing out over time toward 0 (the setup or current pose value) or
+ * mixing in toward 1 (the timeline's value).
+ *
+ * See Timeline {@link Timeline#apply(Skeleton, float, float, Array, float, MixBlend, MixDirection)}.
+ * @public
+ * */
+export declare enum MixDirection {
+    mixIn = 0,
+    mixOut = 1
+}
+/**
+ * @public
+ */
+export interface IAnimation<Timeline extends ITimeline = ITimeline> {
+    name: string;
+    timelines: Timeline[];
+    duration: number;
+}
+/**
+ * @public
+ */
+export interface IAnimationState<AnimationStateData extends IAnimationStateData = IAnimationStateData> {
+    data: AnimationStateData;
+    tracks: ITrackEntry[];
+    listeners: IAnimationStateListener[];
+    timeScale: number;
+    update(dt: number): void;
+    apply(skeleton: ISkeleton): boolean;
+    setAnimation(trackIndex: number, animationName: string, loop: boolean): ITrackEntry;
+    addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): ITrackEntry;
+    addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): ITrackEntry;
+    setEmptyAnimation(trackIndex: number, mixDuration: number): ITrackEntry;
+    setEmptyAnimations(mixDuration: number): void;
+    hasAnimation(animationName: string): boolean;
+    addListener(listener: IAnimationStateListener): void;
+    removeListener(listener: IAnimationStateListener): void;
+    clearListeners(): void;
+    clearTracks(): void;
+    clearTrack(index: number): void;
+}
+/**
+ * @public
+ */
+export interface IAnimationStateData<SkeletonData extends ISkeletonData = ISkeletonData, Animation extends IAnimation = IAnimation> {
+    skeletonData: SkeletonData;
+    animationToMixTime: StringMap<number>;
+    defaultMix: number;
+    setMix(fromName: string, toName: string, duration: number): void;
+    setMixWith(from: Animation, to: Animation, duration: number): void;
+    getMix(from: Animation, to: Animation): number;
+}
+/**
+ * @public
+ */
+export interface IAnimationStateListener {
+    start?(entry: ITrackEntry): void;
+    interrupt?(entry: ITrackEntry): void;
+    end?(entry: ITrackEntry): void;
+    dispose?(entry: ITrackEntry): void;
+    complete?(entry: ITrackEntry): void;
+    event?(entry: ITrackEntry, event: IEvent): void;
+}
+/**
+ * @public
+ */
+export interface ITimeline {
+}
+/**
+ * @public
+ */
+export interface ITrackEntry {
+    trackIndex: number;
+    loop: boolean;
+    animationEnd: number;
+    listener: IAnimationStateListener;
+    delay: number;
+    trackTime: number;
+    trackLast: number;
+    nextTrackLast: number;
+    trackEnd: number;
+    timeScale: number;
+    alpha: number;
+    mixTime: number;
+    mixDuration: number;
+    interruptAlpha: number;
+    totalAlpha: number;
+}
+/**
+ * @public
+ */
+export interface IEventData {
+    name: string;
+}
+/**
+ * @public
+ */
+export interface IEvent {
+    time: number;
+    data: IEventData;
+}

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

@@ -0,0 +1,93 @@
+/** Controls how the first bone is positioned along the path.
+ *
+ * See [Position mode](http://esotericsoftware.com/spine-path-constraints#Position-mode) in the Spine User Guide.
+ * @public
+ * */
+export declare enum PositionMode {
+    Fixed = 0,
+    Percent = 1
+}
+/** Controls how bones are rotated, translated, and scaled to match the path.
+ *
+ * [Rotate mode](http://esotericsoftware.com/spine-path-constraints#Rotate-mod) in the Spine User Guide.
+ * @public
+ * */
+export declare enum RotateMode {
+    Tangent = 0,
+    Chain = 1,
+    ChainScale = 2
+}
+/**
+ * @public
+ */
+export interface IConstraintData {
+    name: string;
+    order: number;
+}
+/**
+ * @public
+ */
+export interface IIkConstraint {
+    data: IIkConstraintData;
+    /** -1 | 0 | 1 */
+    bendDirection: number;
+    compress: boolean;
+    stretch: boolean;
+    /** A percentage (0-1) */
+    mix: number;
+}
+/**
+ * @public
+ */
+export interface IIkConstraintData extends IConstraintData {
+    /** -1 | 0 | 1 */
+    bendDirection: number;
+    compress: boolean;
+    stretch: boolean;
+    uniform: boolean;
+    /** A percentage (0-1) */
+    mix: number;
+}
+/**
+ * @public
+ */
+export interface IPathConstraint {
+    data: IPathConstraintData;
+    position: number;
+    spacing: number;
+    spaces: number[];
+    positions: number[];
+    world: number[];
+    curves: number[];
+    lengths: number[];
+    segments: number[];
+}
+/**
+ * @public
+ */
+export interface IPathConstraintData extends IConstraintData {
+    positionMode: PositionMode;
+    rotateMode: RotateMode;
+    offsetRotation: number;
+    position: number;
+    spacing: number;
+}
+/**
+ * @public
+ */
+export interface ITransformConstraint {
+    data: ITransformConstraintData;
+}
+/**
+ * @public
+ */
+export interface ITransformConstraintData extends IConstraintData {
+    offsetRotation: number;
+    offsetX: number;
+    offsetY: number;
+    offsetScaleX: number;
+    offsetScaleY: number;
+    offsetShearY: number;
+    relative: boolean;
+    local: boolean;
+}