@melonjs/spine-plugin 1.4.0 → 2.0.0

package/build/Spine.d.ts

@@ -0,0 +1,320 @@
+/**
+ * @classdesc
+ * A renderable object to render Spine animated skeleton.
+ * @augments Renderable
+ */
+export default class Spine extends Renderable {
+    /**
+     * @param {number} x - the x coordinates of the Spine object
+     * @param {number} y - the y coordinates of the Spine object
+     * @param {object} settings - Configuration parameters for the Spine object
+     * @param {string} [settings.atlasFile] - the name of the atlasFile to be used to create this spine animation
+     * @param {string} [settings.jsonFile] - the name of the jsonFile to be used to create this spine animation
+     * @param {number} [settings.mixTime = 0.2] - the default mix duration to use when no mix duration has been defined between two animations.
+     * @example
+     * import Spine, { SpinePlugin } from '@melonjs/spine-plugin';
+     * import * as me from 'melonjs';
+     *
+     * // register the plugin
+     * me.plugin.register(SpinePlugin);
+     *
+     * // prepare/declare assets for the preloader
+     * const DataManifest = [
+     *     {
+     *         "name": "alien-ess.json",
+     *         "type": "spine",
+     *         "src": "data/spine/alien-ess.json"
+     *     },
+     *     {
+     *         "name": "alien.atlas",
+     *         "type": "spine",
+     *         "src": "data/spine/alien.atlas"
+     *     },
+     * ]
+     *
+     * // create a new Spine Renderable
+     * let spineAlien = new Spine(100, 100, {atlasFile: "alien.atlas", jsonFile: "alien-ess.json"});
+     *
+     * // set default animation
+     * spineAlien.setAnimation(0, "death", true);
+     *
+     * // add it to the game world
+     * me.game.world.addChild(spineAlien);
+     */
+    constructor(x: number, y: number, settings: {
+        atlasFile?: string | undefined;
+        jsonFile?: string | undefined;
+        mixTime?: number | undefined;
+    });
+    runtime: typeof spineWebGL | typeof spineCanvas;
+    skeleton: any;
+    plugin: plugin.BasePlugin;
+    renderer: import("melonjs").Renderer;
+    animationState: any;
+    skeletonRenderer: SkeletonRenderer | spineWebGL.SkeletonRenderer;
+    root: any;
+    boneOffset: spineCanvas.Vector2;
+    boneSize: spineCanvas.Vector2;
+    isSpineFlipped: {
+        x: boolean;
+        y: boolean;
+    };
+    /**
+     * Stores settings and other state for the playback of the current animation (if any).
+     * @type {TrackEntry}
+     * @see http://en.esotericsoftware.com/spine-api-reference#TrackEntry
+     * @see setAnimation
+     * @default undefined
+     * @example
+     * // set a default animation to "run"
+     * this.setAnimation(0, "run", true);
+     * ...
+     * ...
+     * // pause the animation
+     * this.currentTrack.timeScale = 0;
+     * ...
+     * ...
+     * // resume the animation
+     * this.currentTrack.timeScale = 1;
+     */
+    currentTrack: TrackEntry;
+    gl: any;
+    canvas: any;
+    context: import("melonjs").Renderer | undefined;
+    twoColorTint: boolean | undefined;
+    spineBatcher: any;
+    shapesShader: spineWebGL.Shader | undefined;
+    shapes: spineWebGL.ShapeRenderer | undefined;
+    skeletonDebugRenderer: spineWebGL.SkeletonDebugRenderer | undefined;
+    mixTime: number;
+    jsonFile: string | undefined;
+    atlasFile: string | undefined;
+    set debugRendering(value: boolean);
+    /**
+     * Whether to enable the debug mode when rendering the spine object
+     * @default false
+     * @type {boolean}
+     */
+    get debugRendering(): boolean;
+    /**
+     * Set and load the given skeleton atlas and json definition files.
+     * (use this if you did not specify any json or atlas through the constructor)
+     * @param {string} atlasFile - the name of the atlasFile to be used to create this spine animation
+     * @param {string} jsonFile - the name of the jsonFile to be used to create this spine animation
+     * @example
+     * // create a new Spine Renderable
+     * let spineAlien = new Spine(100, 100);
+     *
+     * // set the skeleton
+     * spineAlien.setSkeleton("alien.atlas", "alien-ess.json");
+     *
+     * // set default animation
+     * spineAlien.setAnimation(0, "death", true);
+     *
+     * // add it to the game world
+     * me.game.world.addChild(spineAlien);
+     */
+    setSkeleton(atlasFile: string, jsonFile: string): void;
+    /**
+     * Flip the Spine skeleton on the horizontal axis (around its center).
+     * @param {boolean} [flip=true] - `true` to flip this Spine object.
+     * @returns {Spine} Reference to this object for method chaining
+     */
+    flipX(flip?: boolean): Spine;
+    /**
+     * Flip the Spine skeleton on the vertical axis (around its center).
+     * @param {boolean} [flip=true] - `true` to flip this Spine object.
+     * @returns {Spine} Reference to this object for method chaining
+     */
+    flipY(flip?: boolean): Spine;
+    /**
+     * Rotate this Spine object by the specified angle (in radians).
+     * @param {number} angle - The angle to rotate (in radians)
+     * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
+     * @returns {Spine} Reference to this object for method chaining
+     */
+    rotate(angle: number, v?: Vector2d | ObservableVector2d): Spine;
+    /**
+     * Scale the Spine object around its anchor point.
+     * @param {number} x - a number representing the abscissa of the scaling vector.
+     * @param {number} [y=x] - a number representing the ordinate of the scaling vector.
+     * @returns {Spine} Reference to this object for method chaining
+     */
+    scale(x: number, y?: number): Spine;
+    /**
+     * Update the bounding box for this spine object.
+     * (this will automatically update the bounds of the entire skeleton animation)
+     * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates
+     * @returns {Bounds} this shape bounding box Rectangle object
+     */
+    updateBounds(absolute?: boolean): Bounds;
+    /**
+     * Draw this Spine object using the appropriate renderer.
+     * If WebGL, it uses the melonJS SpineBatcher for two-color tinted rendering.
+     * Otherwise, it falls back to the canvas skeleton renderer.
+     *
+     * @param {CanvasRenderer|WebGLRenderer} renderer - A renderer instance.
+     */
+    draw(renderer: CanvasRenderer | WebGLRenderer): void;
+    /**
+     * Disposes of all rendering-related resources to free GPU memory.
+     * Called automatically when the renderable is removed from the world.
+     */
+    dispose(): void;
+    /**
+     * Sets the current animation for a track by animation index, discarding any queued animations.
+     * @param {number} trackIndex - the track index
+     * @param {number} index - the animation index
+     * @param {boolean} [loop=false] - If true, the animation will repeat.
+     * @returns {TrackEntry} A track entry to allow further customization of animation playback.
+     */
+    setAnimationByIndex(trackIndex: number, index: number, loop?: boolean): TrackEntry;
+    /**
+     * Sets the current animation for a track, discarding any queued animations.
+     * @param {number} trackIndex - the track index
+     * @param {string} name - the animation name
+     * @param {boolean} [loop=false] - If true, the animation will repeat.
+     * @returns {TrackEntry} A track entry to allow further customization of animation playback.
+     * @example
+     * // set the current animation
+     * spineAlien.setAnimation(0, "death", true);
+     */
+    setAnimation(trackIndex: number, name: string, loop?: boolean): TrackEntry;
+    /**
+     * Return true if the given animation name is the current running animation for the current track.
+     * @param {string} name - animation name
+     * @returns {boolean}
+     * @example
+     * if (!this.isCurrentAnimation("death")) {
+     *     // do something funny...
+     * }
+     */
+    isCurrentAnimation(name: string): boolean;
+    /**
+     * Adds an animation to be played after the current or last queued animation for a track, by index.
+     * @param {number} trackIndex - the track index
+     * @param {number} index - the animation index
+     * @param {boolean} [loop=false] - If true, the animation will repeat.
+     * @param {number} [delay=0] - delay in seconds before playing the animation
+     * @returns {TrackEntry} A track entry to allow further customization of animation playback.
+     */
+    addAnimationByIndex(trackIndex: number, index: number, loop?: boolean, delay?: number): TrackEntry;
+    /**
+     * Adds an animation to be played after the current or last queued animation for a track, by name.
+     * @param {number} trackIndex - the track index
+     * @param {string} name - the animation name
+     * @param {boolean} [loop=false] - If true, the animation will repeat.
+     * @param {number} [delay=0] - delay in seconds before playing the animation
+     * @returns {TrackEntry} A track entry to allow further customization of animation playback.
+     */
+    addAnimation(trackIndex: number, name: string, loop?: boolean, delay?: number): TrackEntry;
+    /**
+     * Set the default mix duration to use when no mix duration has been defined between two animations.
+     * @param {number} mixTime
+     */
+    setDefaultMixTime(mixTime: number): void;
+    /**
+     * Sets a mix duration between two animations by name.
+     * @param {string} firstAnimation - the name of the first animation
+     * @param {string} secondAnimation - the name of the second animation
+     * @param {number} mixTime - the mix duration in seconds
+     */
+    setTransitionMixTime(firstAnimation: string, secondAnimation: string, mixTime: number): void;
+    /**
+     * Sets a skin by name.
+     * @param {string} skinName
+     * @example
+     * // create a new Spine Renderable
+     * let spineChar = new Spine(100, 100, {atlasFile: "mix-and-match-pma.atlas", jsonFile: "mix-and-match-pro.json"});
+     *
+     * // set default animation
+     * spineChar.setAnimation(0, "dance", true);
+     *
+     * // set skin
+     * spineChar.setSkinByName("full-skins/girl");
+     *
+     * // add it to the game world
+     * me.game.world.addChild(spineChar);
+     */
+    setSkinByName(skinName: string): void;
+    /**
+     * Create a combined skin from multiple skin names (mix-and-match).
+     * @param {string} combinedName - name for the new combined skin
+     * @param {...string} skinNames - names of skins to combine
+     * @example
+     * // combine multiple skins for mix-and-match
+     * spineChar.setCombinedSkin("custom", "skin-base", "nose/short", "eyelids/girly");
+     */
+    setCombinedSkin(combinedName: string, ...skinNames: string[]): void;
+    /**
+     * Sets an empty animation for a track, allowing the track entry to be mixed from.
+     * @param {number} trackIndex - the track index
+     * @param {number} [mixDuration=0] - mix duration in seconds
+     * @returns {TrackEntry} A track entry to allow further customization.
+     */
+    setEmptyAnimation(trackIndex: number, mixDuration?: number): TrackEntry;
+    /**
+     * Find a bone by name.
+     * @param {string} boneName - the bone name
+     * @returns {Bone|null} the bone, or null if not found
+     */
+    findBone(boneName: string): Bone | null;
+    /**
+     * Find a slot by name.
+     * @param {string} slotName - the slot name
+     * @returns {Slot|null} the slot, or null if not found
+     */
+    findSlot(slotName: string): Slot | null;
+    /**
+     * Register a listener for animation state events.
+     * @param {object} listener - an object with event handler methods
+     * @param {Function} [listener.start] - called when an animation starts
+     * @param {Function} [listener.interrupt] - called when an animation is interrupted
+     * @param {Function} [listener.end] - called when an animation ends
+     * @param {Function} [listener.dispose] - called when a track entry is disposed
+     * @param {Function} [listener.complete] - called when an animation completes a loop
+     * @param {Function} [listener.event] - called when a user-defined event fires
+     * @example
+     * spineObj.addAnimationListener({
+     *     complete: (entry) => {
+     *         console.log("Animation complete:", entry.animation.name);
+     *     },
+     *     event: (entry, event) => {
+     *         console.log("Event:", event.data.name);
+     *     }
+     * });
+     */
+    addAnimationListener(listener: {
+        start?: Function | undefined;
+        interrupt?: Function | undefined;
+        end?: Function | undefined;
+        dispose?: Function | undefined;
+        complete?: Function | undefined;
+        event?: Function | undefined;
+    }): void;
+    /**
+     * Remove a previously registered animation state listener.
+     * @param {object} listener - the listener to remove
+     */
+    removeAnimationListener(listener: object): void;
+    /**
+     * Get the list of animation names available in this skeleton.
+     * @returns {string[]} array of animation names
+     */
+    getAnimationNames(): string[];
+    /**
+     * Get the list of skin names available in this skeleton.
+     * @returns {string[]} array of skin names
+     */
+    getSkinNames(): string[];
+    /**
+     * Reset this skeleton to the setup pose.
+     */
+    setToSetupPose(): void;
+}
+import { Renderable } from "melonjs";
+import * as spineWebGL from "@esotericsoftware/spine-webgl";
+import * as spineCanvas from "@esotericsoftware/spine-canvas";
+import { plugin } from "melonjs";
+import SkeletonRenderer from "./SkeletonRenderer.js";
+//# sourceMappingURL=Spine.d.ts.map

package/build/Spine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Spine.d.ts","sourceRoot":"","sources":["../src/Spine.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IAmCC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,eApCW,MAAM,KACN,MAAM,YAEd;QAA0B,SAAS;QACT,QAAQ;QACR,OAAO;KACjC,EA+FF;IAxID,gDAAQ;IACR,cAAS;IACT,0BAAO;IACP,qCAAS;IACT,oBAAe;IACf,iEAAiB;IACjB,UAAK;IACL,gCAAW;IACX,8BAAS;IACT;;;MAGE;IAEF;;;;;;;;;;;;;;;;;OAiBG;IACH,cAhBU,UAAU,CAgBP;IAqDX,QAA0B;IAC1B,YAA+C;IAC/C,gDAA4B;IAC5B,kCAAwB;IASxB,kBAAuD;IASvD,4CAA+D;IAC/D,6CAAyD;IACzD,oEAEC;IAmBF,gBAAsC;IAGrC,6BAAiC;IACjC,8BAAmC;IAcrC,0BANU,OAAO,EAQhB;IAXD;;;;OAIG;IACH,sBAFU,OAAO,CAIhB;IAMD;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAfW,MAAM,YACN,MAAM,QA2DhB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,KAAK,CASjB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,KAAK,CASjB;IAED;;;;;OAKG;IACH,cAJW,MAAM,MACN,QAAQ,GAAC,kBAAkB,GACzB,KAAK,CAWjB;IAED;;;;;OAKG;IACH,SAJW,MAAM,MACN,MAAM,GACJ,KAAK,CAMjB;IAED;;;;;OAKG;IACH,wBAHW,OAAO,GACL,MAAM,CA6ClB;IAgCD;;;;;;OAMG;IACH,eAFW,cAAc,GAAC,aAAa,QAoCtC;IAED;;;OAGG;IACH,gBAMC;IAWD;;;;;;OAMG;IACH,gCALW,MAAM,SACN,MAAM,SACN,OAAO,GACL,UAAU,CAYtB;IAED;;;;;;;;;OASG;IACH,yBARW,MAAM,QACN,MAAM,SACN,OAAO,GACL,UAAU,CAYtB;IAED;;;;;;;;OAQG;IACH,yBAPW,MAAM,GACJ,OAAO,CAWnB;IAED;;;;;;;OAOG;IACH,gCANW,MAAM,SACN,MAAM,SACN,OAAO,UACP,MAAM,GACJ,UAAU,CAatB;IAED;;;;;;;OAOG;IACH,yBANW,MAAM,QACN,MAAM,SACN,OAAO,UACP,MAAM,GACJ,UAAU,CAItB;IAED;;;OAGG;IACH,2BAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,qCAJW,MAAM,mBACN,MAAM,WACN,MAAM,QAIhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,wBAdW,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,8BANW,MAAM,gBACH,MAAM,EAAA,QAkBnB;IAED;;;;;OAKG;IACH,8BAJW,MAAM,gBACN,MAAM,GACJ,UAAU,CAItB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAIrB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAIrB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,+BAhBG;QAA4B,KAAK;QACL,SAAS;QACT,GAAG;QACH,OAAO;QACP,QAAQ;QACR,KAAK;KACjC,QAYF;IAED;;;OAGG;IACH,kCAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,qBAFa,MAAM,EAAE,CAMpB;IAED;;;OAGG;IACH,gBAFa,MAAM,EAAE,CAMpB;IAED;;OAEG;IACH,uBAYC;CACD;2BAnqBwC,SAAS;4BADtB,+BAA+B;6BAF9B,gCAAgC;uBAGpB,SAAS;6BACrB,uBAAuB"}

package/build/SpineBatcher.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A custom melonJS Batcher for rendering Spine skeletons with two-color tinting.
+ * Uses Spine's official two-color shader and the base Batcher's indexed drawing support.
+ * @category Rendering
+ */
+export default class SpineBatcher extends Batcher {
+    /**
+     * @param {WebGLRenderer} renderer - the current WebGL renderer session
+     * @param {WebGLRenderingContext|WebGL2RenderingContext} canvas - the GL context for Spine shader creation
+     */
+    constructor(renderer: WebGLRenderer, canvas: WebGLRenderingContext | WebGL2RenderingContext);
+    /**
+     * the current texture bound to the batcher
+     * @type {object|null}
+     * @ignore
+     */
+    lastTexture: object | null;
+    /**
+     * Set the blend mode for subsequent draw calls.
+     * Maps Spine BlendMode enum to melonJS blend mode strings.
+     * @param {number} blendMode - Spine BlendMode enum value (0=Normal, 1=Additive, 2=Multiply, 3=Screen)
+     * @param {boolean} premultipliedAlpha - whether textures use premultiplied alpha
+     */
+    setBlendMode(blendMode: number, premultipliedAlpha: boolean): void;
+    /**
+     * Draw Spine vertices with the given texture and triangle indices.
+     * This matches the Spine PolygonBatcher.draw() API.
+     * @param {object} texture - a Spine GLTexture object
+     * @param {ArrayLike<number>} vertices - interleaved vertex data
+     * @param {number[]} indices - triangle index array
+     */
+    draw(texture: object, vertices: ArrayLike<number>, indices: number[]): void;
+}
+import { Batcher } from "melonjs";
+//# sourceMappingURL=SpineBatcher.d.ts.map

package/build/SpineBatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpineBatcher.d.ts","sourceRoot":"","sources":["../src/SpineBatcher.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH;IACC;;;OAGG;IACH,sBAHW,aAAa,UACb,qBAAqB,GAAC,sBAAsB,EAuDtD;IANA;;;;OAIG;IACH,aAHU,MAAM,GAAC,IAAI,CAGE;IAGxB;;;;;OAKG;IACH,wBAHW,MAAM,sBACN,OAAO,QAOjB;IAED;;;;;;OAMG;IACH,cAJW,MAAM,YACN,SAAS,CAAC,MAAM,CAAC,WACjB,MAAM,EAAE,QAwBlB;CAaD;wBArIuB,SAAS"}

package/build/SpinePlugin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @classdesc
+ * a Spine 4.x plugin implementation for melonJS
+ * @augments plugin.BasePlugin
+ */
+export class SpinePlugin extends plugin.BasePlugin {
+    constructor();
+    assetManager: AssetManager;
+}
+import { plugin } from "melonjs";
+import AssetManager from "./AssetManager";
+//# sourceMappingURL=SpinePlugin.d.ts.map

package/build/SpinePlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpinePlugin.d.ts","sourceRoot":"","sources":["../src/SpinePlugin.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH;IACC,cAcC;IADA,2BAAuD;CAExD;uBA/BsB,SAAS;yBAQP,gBAAgB"}

package/build/index.d.ts

@@ -0,0 +1,3 @@
+export { SpinePlugin } from "./SpinePlugin.js";
+export { default, default as Spine } from "./Spine.js";
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":""}