@safe-engine/cocos 2.6.3 → 2.6.5

package/dist/spine/CCSkeleton.js

@@ -0,0 +1,344 @@
+import * as spine from '@esotericsoftware/spine-core';
+import { AtlasAttachmentLoader, SkeletonJson, TextureAtlas } from '@esotericsoftware/spine-core';
+import { _atlasLoader } from './CCSkeletonAnimation';
+import { CanvasRenderCmd } from './CCSkeletonCanvasRenderCmd';
+import { WebGLRenderCmd } from './CCSkeletonWebGLRenderCmd';
+/****************************************************************************
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+ Copyright (c) 2014 Shengxiang Chen (Nero Chan)
+
+ http://www.cocos2d-x.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+/**
+ * The main namespace of Spine, all classes, functions, properties and constants of Spine are defined in this namespace
+ * @namespace
+ * @name gworld
+ */
+var gworld = gworld || {};
+/**
+ * <p>
+ *     The skeleton of Spine.                                                                          <br/>
+ *     Skeleton has a reference to a SkeletonData and stores the state for skeleton instance,
+ *     which consists of the current pose's bone SRT, slot colors, and which slot attachments are visible.           <br/>
+ *     Multiple skeletons can use the same SkeletonData (which includes all animations, skins, and attachments).     <br/>
+ * </p>
+ * @class
+ * @extends cc.Node
+ */
+gworld.Skeleton = cc.Node.extend(
+/** @lends gworld.Skeleton# */ {
+    _skeleton: null,
+    _rootBone: null,
+    _timeScale: 1,
+    _debugSlots: false,
+    _debugBones: false,
+    _premultipliedAlpha: false,
+    _ownsSkeletonData: null,
+    _atlas: null,
+    /**
+     * The constructor of gworld.Skeleton. override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function.
+     */
+    ctor: function (skeletonDataFile, atlasFile, scale) {
+        cc.Node.prototype.ctor.call(this);
+        if (arguments.length === 0)
+            this.init();
+        else
+            this.initWithArgs(skeletonDataFile, atlasFile, scale);
+    },
+    _createRenderCmd: function () {
+        if (cc._renderType === cc.game.RENDER_TYPE_CANVAS)
+            return new CanvasRenderCmd(this);
+        else
+            return new WebGLRenderCmd(this);
+    },
+    /**
+     * Initializes a gworld.Skeleton. please do not call this function by yourself, you should pass the parameters to constructor to initialize it.
+     */
+    init: function () {
+        cc.Node.prototype.init.call(this);
+        this._premultipliedAlpha = cc._renderType === cc.game.RENDER_TYPE_WEBGL && cc.OPTIMIZE_BLEND_FUNC_FOR_PREMULTIPLIED_ALPHA;
+    },
+    onEnter: function () {
+        cc.Node.prototype.onEnter.call(this);
+        this.scheduleUpdate();
+    },
+    onExit: function () {
+        this.unscheduleUpdate();
+        cc.Node.prototype.onExit.call(this);
+    },
+    /**
+     * Sets whether open debug slots.
+     * @param {boolean} enable true to open, false to close.
+     */
+    setDebugSolots: function (enable) {
+        this._debugSlots = enable;
+    },
+    /**
+     * Sets whether open debug bones.
+     * @param {boolean} enable
+     */
+    setDebugBones: function (enable) {
+        this._debugBones = enable;
+    },
+    /**
+     * Sets whether open debug slots.
+     * @param {boolean} enabled true to open, false to close.
+     */
+    setDebugSlotsEnabled: function (enabled) {
+        this._debugSlots = enabled;
+    },
+    /**
+     * Gets whether open debug slots.
+     * @returns {boolean} true to open, false to close.
+     */
+    getDebugSlotsEnabled: function () {
+        return this._debugSlots;
+    },
+    /**
+     * Sets whether open debug bones.
+     * @param {boolean} enabled
+     */
+    setDebugBonesEnabled: function (enabled) {
+        this._debugBones = enabled;
+    },
+    /**
+     * Gets whether open debug bones.
+     * @returns {boolean} true to open, false to close.
+     */
+    getDebugBonesEnabled: function () {
+        return this._debugBones;
+    },
+    /**
+     * Sets the time scale of gworld.Skeleton.
+     * @param {Number} scale
+     */
+    setTimeScale: function (scale) {
+        this._timeScale = scale;
+    },
+    getTimeScale: function () {
+        return this._timeScale;
+    },
+    /**
+     * Initializes gworld.Skeleton with Data.
+     * @param {gworld.spine.SkeletonData|String} skeletonDataFile
+     * @param {String|spine.Atlas|spine.SkeletonData} atlasFile atlas filename or atlas data or owns SkeletonData
+     * @param {Number} [scale] scale can be specified on the JSON or binary loader which will scale the bone positions, image sizes, and animation translations.
+     */
+    initWithArgs: function (skeletonDataFile, atlasFile, scale) {
+        let argSkeletonFile = skeletonDataFile, argAtlasFile = atlasFile, skeletonData, atlas, ownsSkeletonData;
+        if (cc.isString(argSkeletonFile)) {
+            if (cc.isString(argAtlasFile)) {
+                const data = cc.loader.getRes(argAtlasFile);
+                _atlasLoader.setAtlasFile(argAtlasFile);
+                atlas = new TextureAtlas(data);
+                for (const page of atlas.pages) {
+                    const texture = _atlasLoader.load(page.name);
+                    page.setTexture(texture);
+                }
+            }
+            scale = scale || 1 / cc.director.getContentScaleFactor();
+            const attachmentLoader = new AtlasAttachmentLoader(atlas);
+            const skeletonJsonReader = new SkeletonJson(attachmentLoader);
+            skeletonJsonReader.scale = scale;
+            const skeletonJson = cc.loader.getRes(argSkeletonFile);
+            skeletonData = skeletonJsonReader.readSkeletonData(skeletonJson);
+            atlas.dispose(skeletonJsonReader);
+            ownsSkeletonData = true;
+        }
+        else {
+            skeletonData = skeletonDataFile;
+            ownsSkeletonData = atlasFile;
+        }
+        this.setSkeletonData(skeletonData, ownsSkeletonData);
+        this.init();
+    },
+    /**
+     * Returns the bounding box of gworld.Skeleton.
+     * @returns {cc.Rect}
+     */
+    getBoundingBox: function () {
+        let minX = cc.FLT_MAX, minY = cc.FLT_MAX, maxX = cc.FLT_MIN, maxY = cc.FLT_MIN;
+        let scaleX = this.getScaleX(), scaleY = this.getScaleY(), vertices, slots = this._skeleton.slots, VERTEX = spine.RegionAttachment;
+        for (let i = 0, slotCount = slots.length; i < slotCount; ++i) {
+            const slot = slots[i];
+            const attachment = slot.attachment;
+            if (!attachment || !(attachment instanceof spine.RegionAttachment))
+                continue;
+            vertices = spine.Utils.setArraySize([], 8, 0);
+            attachment.computeWorldVertices(slot, vertices, 0, 2);
+            minX = Math.min(minX, vertices[VERTEX.X1] * scaleX, vertices[VERTEX.X4] * scaleX, vertices[VERTEX.X2] * scaleX, vertices[VERTEX.X3] * scaleX);
+            minY = Math.min(minY, vertices[VERTEX.Y1] * scaleY, vertices[VERTEX.Y4] * scaleY, vertices[VERTEX.Y2] * scaleY, vertices[VERTEX.Y3] * scaleY);
+            maxX = Math.max(maxX, vertices[VERTEX.X1] * scaleX, vertices[VERTEX.X4] * scaleX, vertices[VERTEX.X2] * scaleX, vertices[VERTEX.X3] * scaleX);
+            maxY = Math.max(maxY, vertices[VERTEX.Y1] * scaleY, vertices[VERTEX.Y4] * scaleY, vertices[VERTEX.Y2] * scaleY, vertices[VERTEX.Y3] * scaleY);
+        }
+        const position = this.getPosition();
+        return cc.rect(position.x + minX, position.y + minY, maxX - minX, maxY - minY);
+    },
+    /**
+     * Computes the world SRT from the local SRT for each bone.
+     */
+    updateWorldTransform: function () {
+        this._skeleton.updateWorldTransform(true);
+    },
+    /**
+     * Sets the bones and slots to the setup pose.
+     */
+    setToSetupPose: function () {
+        this._skeleton.setToSetupPose();
+    },
+    /**
+     * Sets the bones to the setup pose, using the values from the `BoneData` list in the `SkeletonData`.
+     */
+    setBonesToSetupPose: function () {
+        this._skeleton.setBonesToSetupPose();
+    },
+    /**
+     * Sets the slots to the setup pose, using the values from the `SlotData` list in the `SkeletonData`.
+     */
+    setSlotsToSetupPose: function () {
+        this._skeleton.setSlotsToSetupPose();
+    },
+    /**
+     * Finds a bone by name. This does a string comparison for every bone.
+     * @param {String} boneName
+     * @returns {gworld.spine.Bone}
+     */
+    findBone: function (boneName) {
+        return this._skeleton.findBone(boneName);
+    },
+    /**
+     * Finds a slot by name. This does a string comparison for every slot.
+     * @param {String} slotName
+     * @returns {gworld.spine.Slot}
+     */
+    findSlot: function (slotName) {
+        return this._skeleton.findSlot(slotName);
+    },
+    /**
+     * Finds a skin by name and makes it the active skin. This does a string comparison for every skin. Note that setting the skin does not change which attachments are visible.
+     * @param {string} skinName
+     * @returns {gworld.spine.Skin}
+     */
+    setSkin: function (skinName) {
+        return this._skeleton.setSkinByName(skinName);
+    },
+    /**
+     * Returns the attachment for the slot and attachment name. The skeleton looks first in its skin, then in the skeleton data’s default skin.
+     * @param {String} slotName
+     * @param {String} attachmentName
+     * @returns {gworld.spine.Attachment}
+     */
+    getAttachment: function (slotName, attachmentName) {
+        return this._skeleton.getAttachmentByName(slotName, attachmentName);
+    },
+    /**
+     * Sets the attachment for the slot and attachment name. The skeleton looks first in its skin, then in the skeleton data’s default skin.
+     * @param {String} slotName
+     * @param {String} attachmentName
+     */
+    setAttachment: function (slotName, attachmentName) {
+        this._skeleton.setAttachment(slotName, attachmentName);
+    },
+    /**
+     * Sets the premultiplied alpha value to gworld.Skeleton.
+     * @param {Number} alpha
+     */
+    setPremultipliedAlpha: function (premultiplied) {
+        this._premultipliedAlpha = premultiplied;
+    },
+    /**
+     * Returns whether to enable premultiplied alpha.
+     * @returns {boolean}
+     */
+    isPremultipliedAlpha: function () {
+        return this._premultipliedAlpha;
+    },
+    /**
+     * Sets skeleton data to gworld.Skeleton.
+     * @param {gworld.spine.SkeletonData} skeletonData
+     * @param {gworld.spine.SkeletonData} ownsSkeletonData
+     */
+    setSkeletonData: function (skeletonData, ownsSkeletonData) {
+        if (skeletonData.width != null && skeletonData.height != null)
+            this.setContentSize(skeletonData.width / cc.director.getContentScaleFactor(), skeletonData.height / cc.director.getContentScaleFactor());
+        this._skeleton = new spine.Skeleton(skeletonData);
+        this._skeleton.updateWorldTransform(true);
+        this._rootBone = this._skeleton.getRootBone();
+        this._ownsSkeletonData = ownsSkeletonData;
+        this._renderCmd._createChildFormSkeletonData();
+    },
+    /**
+     * Return the renderer of attachment.
+     * @param {gworld.spine.RegionAttachment|gworld.spine.BoundingBoxAttachment} regionAttachment
+     * @returns {gworld.spine.TextureAtlasRegion}
+     */
+    getTextureAtlas: function (regionAttachment) {
+        return regionAttachment.region;
+    },
+    /**
+     * Returns the blendFunc of gworld.Skeleton.
+     * @returns {cc.BlendFunc}
+     */
+    getBlendFunc: function () {
+        const slot = this._skeleton.drawOrder[0];
+        if (slot) {
+            const blend = this._renderCmd._getBlendFunc(slot.data.blendMode, this._premultipliedAlpha);
+            return blend;
+        }
+        else {
+            return {};
+        }
+    },
+    /**
+     * Sets the blendFunc of gworld.Skeleton, it won't have any effect for skeleton, skeleton is using slot's data to determine the blend function.
+     * @param {cc.BlendFunc|Number} src
+     * @param {Number} [dst]
+     */
+    setBlendFunc: function (src, dst) {
+        return;
+    },
+    /**
+     * Update will be called automatically every frame if "scheduleUpdate" is called when the node is "live".
+     * @param {Number} dt Delta time since last update
+     */
+    update: function (dt) {
+        this._skeleton.update(dt);
+    },
+});
+cc.defineGetterSetter(gworld.Skeleton.prototype, 'opacityModifyRGB', gworld.Skeleton.prototype.isOpacityModifyRGB);
+// For renderer webgl to identify skeleton's default texture and blend function
+cc.defineGetterSetter(gworld.Skeleton.prototype, '_blendFunc', gworld.Skeleton.prototype.getBlendFunc);
+cc.defineGetterSetter(gworld.Skeleton.prototype, '_texture', function () {
+    return this._renderCmd._currTexture;
+});
+/**
+ * Creates a skeleton object.
+ * @deprecated since v3.0, please use new gworld.Skeleton(skeletonDataFile, atlasFile, scale) instead.
+ * @param {spine.SkeletonData|String} skeletonDataFile
+ * @param {String|spine.Atlas|spine.SkeletonData} atlasFile atlas filename or atlas data or owns SkeletonData
+ * @param {Number} [scale] scale can be specified on the JSON or binary loader which will scale the bone positions, image sizes, and animation translations.
+ * @returns {gworld.Skeleton}
+ */
+gworld.Skeleton.create = function (skeletonDataFile, atlasFile /* or atlas*/, scale) {
+    return new gworld.Skeleton(skeletonDataFile, atlasFile, scale);
+};
+export const Skeleton = gworld.Skeleton;

package/dist/spine/CCSkeletonAnimation.d.ts

@@ -0,0 +1,16 @@
+export declare const _atlasLoader: {
+    spAtlasFile: any;
+    setAtlasFile: (spAtlasFile: any) => void;
+    load: (line: any) => any;
+    unload: (obj: any) => void;
+};
+/**
+ * The skeleton animation of spine. It updates animation's state and skeleton's world transform.
+ * @class
+ * @extends gworld.Skeleton
+ * @example
+ * var spineBoy = new SkeletonAnimation('res/skeletons/spineboy.json', 'res/skeletons/spineboy.atlas');
+ * this.addChild(spineBoy, 4);
+ */
+export declare const SkeletonAnimation: any;
+//# sourceMappingURL=CCSkeletonAnimation.d.ts.map

package/dist/spine/CCSkeletonAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CCSkeletonAnimation.d.ts","sourceRoot":"","sources":["../../src/spine/CCSkeletonAnimation.ts"],"names":[],"mappings":"AA+BA,eAAO,MAAM,YAAY;;;;;CAaxB,CAAA;AA2FD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,KAuM5B,CAAA"}

package/dist/spine/CCSkeletonAnimation.js

@@ -0,0 +1,317 @@
+import * as spine from '@esotericsoftware/spine-core';
+import { Skeleton } from './CCSkeleton';
+import { SkeletonTexture } from './CCSkeletonTexture';
+/****************************************************************************
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+ Copyright (c) 2014 Shengxiang Chen (Nero Chan)
+
+ http://www.cocos2d-x.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+var gworld = gworld || {};
+export const _atlasLoader = {
+    spAtlasFile: null,
+    setAtlasFile: function (spAtlasFile) {
+        this.spAtlasFile = spAtlasFile;
+    },
+    load: function (line) {
+        const texturePath = cc.path.join(cc.path.dirname(this.spAtlasFile), line);
+        const texture = cc.textureCache.addImage(texturePath);
+        const tex = new SkeletonTexture({ width: texture.getPixelsWide(), height: texture.getPixelsHigh() });
+        tex.setRealTexture(texture);
+        return tex;
+    },
+    unload: function (obj) { },
+};
+/**
+ * The event type of spine skeleton animation. It contains event types: START(0), END(1), COMPLETE(2), EVENT(3).
+ * @constant
+ * @type {{START: number, END: number, COMPLETE: number, EVENT: number}}
+ */
+gworld.ANIMATION_EVENT_TYPE = {
+    START: 0,
+    INTERRUPT: 1,
+    END: 2,
+    DISPOSE: 3,
+    COMPLETE: 4,
+    EVENT: 5,
+};
+gworld.TrackEntryListeners = function (startListener, endListener, completeListener, eventListener, interruptListener, disposeListener) {
+    this.startListener = startListener || null;
+    this.endListener = endListener || null;
+    this.completeListener = completeListener || null;
+    this.eventListener = eventListener || null;
+    this.interruptListener = interruptListener || null;
+    this.disposeListener = disposeListener || null;
+    this.callback = null;
+    this.callbackTarget = null;
+    this.skeletonNode = null;
+};
+const proto = gworld.TrackEntryListeners.prototype;
+proto.start = function (trackEntry) {
+    if (this.startListener) {
+        this.startListener(trackEntry);
+    }
+    if (this.callback) {
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.START, null, 0);
+    }
+};
+proto.interrupt = function (trackEntry) {
+    if (this.interruptListener) {
+        this.interruptListener(trackEntry);
+    }
+    if (this.callback) {
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.INTERRUPT, null, 0);
+    }
+};
+proto.end = function (trackEntry) {
+    if (this.endListener) {
+        this.endListener(trackEntry);
+    }
+    if (this.callback) {
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.END, null, 0);
+    }
+};
+proto.dispose = function (trackEntry) {
+    if (this.disposeListener) {
+        this.disposeListener(trackEntry);
+    }
+    if (this.callback) {
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.DISPOSE, null, 0);
+    }
+};
+proto.complete = function (trackEntry) {
+    const loopCount = Math.floor(trackEntry.trackTime / trackEntry.animationEnd);
+    if (this.completeListener) {
+        this.completeListener(trackEntry, loopCount);
+    }
+    if (this.callback) {
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.COMPLETE, null, loopCount);
+    }
+};
+proto.event = function (trackEntry, event) {
+    if (this.eventListener) {
+        this.eventListener(trackEntry, event);
+    }
+    if (this.callback) {
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.EVENT, event, 0);
+    }
+};
+gworld.TrackEntryListeners.getListeners = function (entry) {
+    if (!entry.listener) {
+        entry.listener = new gworld.TrackEntryListeners();
+    }
+    return entry.listener;
+};
+/**
+ * The skeleton animation of spine. It updates animation's state and skeleton's world transform.
+ * @class
+ * @extends gworld.Skeleton
+ * @example
+ * var spineBoy = new SkeletonAnimation('res/skeletons/spineboy.json', 'res/skeletons/spineboy.atlas');
+ * this.addChild(spineBoy, 4);
+ */
+export const SkeletonAnimation = Skeleton.extend({
+    _state: null,
+    _ownsAnimationStateData: false,
+    _listener: null,
+    /**
+     * Initializes a SkeletonAnimation. please do not call this function by yourself, you should pass the parameters to constructor to initialize it.
+     * @override
+     */
+    init: function () {
+        Skeleton.prototype.init.call(this);
+        this._ownsAnimationStateData = true;
+        this.setAnimationStateData(new spine.AnimationStateData(this._skeleton.data));
+    },
+    /**
+     * Sets animation state data to SkeletonAnimation.
+     * @param {gworld.spine.AnimationStateData} stateData
+     */
+    setAnimationStateData: function (stateData) {
+        const state = new spine.AnimationState(stateData);
+        this._listener = new gworld.TrackEntryListeners();
+        // state.rendererObject = this;
+        state.addListener(this._listener);
+        this._state = state;
+    },
+    /**
+     * Mix applies all keyframe values, interpolated for the specified time and mixed with the current values.  <br/>
+     * @param {String} fromAnimation
+     * @param {String} toAnimation
+     * @param {Number} duration
+     */
+    setMix: function (fromAnimation, toAnimation, duration) {
+        this._state.data.setMixWith(fromAnimation, toAnimation, duration);
+    },
+    /**
+     * Sets event listener of SkeletonAnimation.
+     * @param {Object} target
+     * @param {Function} callback
+     */
+    setAnimationListener: function (target, callback) {
+        this._listener.callbackTarget = target;
+        this._listener.callback = callback;
+        this._listener.skeletonNode = this;
+    },
+    /**
+     * Set the current animation. Any queued animations are cleared.
+     * @param {Number} trackIndex
+     * @param {String} name
+     * @param {Boolean} loop
+     * @returns {gworld.spine.TrackEntry|null}
+     */
+    setAnimation: function (trackIndex, name, loop) {
+        const animation = this._skeleton.data.findAnimation(name);
+        if (!animation) {
+            cc.log(`Spine: Animation not found: ${name}`);
+            return null;
+        }
+        return this._state.setAnimationWith(trackIndex, animation, loop);
+    },
+    /**
+     * Adds an animation to be played delay seconds after the current or last queued animation.
+     * @param {Number} trackIndex
+     * @param {String} name
+     * @param {Boolean} loop
+     * @param {Number} [delay=0]
+     * @returns {gworld.spine.TrackEntry|null}
+     */
+    addAnimation: function (trackIndex, name, loop, delay) {
+        delay = delay == null ? 0 : delay;
+        const animation = this._skeleton.data.findAnimation(name);
+        if (!animation) {
+            cc.log(`Spine: Animation not found:${name}`);
+            return null;
+        }
+        return this._state.addAnimationWith(trackIndex, animation, loop, delay);
+    },
+    /**
+     * Find animation with specified name
+     * @param {String} name
+     * @returns {gworld.spine.Animation|null}
+     */
+    findAnimation: function (name) {
+        return this._skeleton.data.findAnimation(name);
+    },
+    /**
+     * Returns track entry by trackIndex.
+     * @param trackIndex
+     * @returns {gworld.spine.TrackEntry|null}
+     */
+    getCurrent: function (trackIndex) {
+        return this._state.getCurrent(trackIndex);
+    },
+    /**
+     * Clears all tracks of animation state.
+     */
+    clearTracks: function () {
+        this._state.clearTracks();
+    },
+    /**
+     * Clears track of animation state by trackIndex.
+     * @param {Number} trackIndex
+     */
+    clearTrack: function (trackIndex) {
+        this._state.clearTrack(trackIndex);
+    },
+    /**
+     * Update will be called automatically every frame if "scheduleUpdate" is called when the node is "live".
+     * It updates animation's state and skeleton's world transform.
+     * @param {Number} dt Delta time since last update
+     * @override
+     */
+    update: function (dt) {
+        this._super(dt);
+        dt *= this._timeScale;
+        this._renderCmd.setDirtyFlag(cc.Node._dirtyFlags.contentDirty);
+        this._state.update(dt);
+        this._state.apply(this._skeleton);
+        this._skeleton.updateWorldTransform(true);
+        this._renderCmd._updateChild();
+    },
+    /**
+     * Set the start event listener.
+     * @param {function} listener
+     */
+    setStartListener: function (listener) {
+        this._listener.startListener = listener;
+    },
+    /**
+     * Set the interrupt listener
+     * @param {function} listener
+     */
+    setInterruptListener: function (listener) {
+        this._listener.interruptListener = listener;
+    },
+    /**
+     * Set the end event listener.
+     * @param {function} listener
+     */
+    setEndListener: function (listener) {
+        this._listener.endListener = listener;
+    },
+    /**
+     * Set the dispose listener
+     * @param {function} listener
+     */
+    setDisposeListener: function (listener) {
+        this._listener.disposeListener = listener;
+    },
+    setCompleteListener: function (listener) {
+        this._listener.completeListener = listener;
+    },
+    setEventListener: function (listener) {
+        this._listener.eventListener = listener;
+    },
+    setTrackStartListener: function (entry, listener) {
+        gworld.TrackEntryListeners.getListeners(entry).startListener = listener;
+    },
+    setTrackInterruptListener: function (entry, listener) {
+        gworld.TrackEntryListeners.getListeners(entry).interruptListener = listener;
+    },
+    setTrackEndListener: function (entry, listener) {
+        gworld.TrackEntryListeners.getListeners(entry).endListener = listener;
+    },
+    setTrackDisposeListener: function (entry, listener) {
+        gworld.TrackEntryListeners.getListeners(entry).disposeListener = listener;
+    },
+    setTrackCompleteListener: function (entry, listener) {
+        gworld.TrackEntryListeners.getListeners(entry).completeListener = listener;
+    },
+    setTrackEventListener: function (entry, listener) {
+        gworld.TrackEntryListeners.getListeners(entry).eventListener = listener;
+    },
+    getState: function () {
+        return this._state;
+    },
+});
+/**
+ * Creates a skeleton animation object.
+ * @deprecated since v3.0, please use new SkeletonAnimation(skeletonDataFile, atlasFile, scale) instead.
+ * @param {spine.SkeletonData|String} skeletonDataFile
+ * @param {String|spine.Atlas|spine.SkeletonData} atlasFile atlas filename or atlas data or owns SkeletonData
+ * @param {Number} [scale] scale can be specified on the JSON or binary loader which will scale the bone positions, image sizes, and animation translations.
+ * @returns {gworld.Skeleton}
+ */
+SkeletonAnimation.createWithJsonFile = SkeletonAnimation.create = function (skeletonDataFile, atlasFile /* or atlas*/, scale) {
+    return new SkeletonAnimation(skeletonDataFile, atlasFile, scale);
+};

package/dist/spine/CCSkeletonCanvasRenderCmd.d.ts

@@ -0,0 +1,2 @@
+export declare const CanvasRenderCmd: any;
+//# sourceMappingURL=CCSkeletonCanvasRenderCmd.d.ts.map

package/dist/spine/CCSkeletonCanvasRenderCmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CCSkeletonCanvasRenderCmd.d.ts","sourceRoot":"","sources":["../../src/spine/CCSkeletonCanvasRenderCmd.ts"],"names":[],"mappings":"AA+PA,eAAO,MAAM,eAAe,KAAyB,CAAA"}