@safe-engine/cocos 2.3.4 → 2.3.6

package/dist/spine/CCSkeletonAnimation.d.ts

@@ -0,0 +1,146 @@
+import { Skeleton } from './CCSkeleton';
+/****************************************************************************
+ 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.
+ ****************************************************************************/
+export declare const _atlasLoader: {
+    spAtlasFile: any;
+    setAtlasFile: (spAtlasFile: any) => void;
+    load: (line: any) => any;
+    unload: () => void;
+};
+/**
+ * The skeleton animation of spine. It updates animation's state and skeleton's world transform.
+ * @class
+ * @extends Skeleton
+ */
+export declare class SkeletonAnimation extends Skeleton {
+    _state: any;
+    _ownsAnimationStateData: boolean;
+    _listener: any;
+    constructor(skeletonDataFile?: any, atlasFile?: any, scale?: number);
+    /**
+     * Sets animation state data to SkeletonAnimation.
+     * @param {spine.AnimationStateData} stateData
+     */
+    setAnimationStateData(stateData: any): void;
+    /**
+     * Mix applies all keyframe values, interpolated for the specified time and mixed with the current values.
+     * @param {String} fromAnimation
+     * @param {String} toAnimation
+     * @param {Number} duration
+     */
+    setMix(fromAnimation: string, toAnimation: string, duration: number): void;
+    /**
+     * Sets event listener of SkeletonAnimation.
+     * @param {Object} target
+     * @param {Function} callback
+     */
+    setAnimationListener(target: any, callback: any): void;
+    /**
+     * Set the current animation. Any queued animations are cleared.
+     * @param {Number} trackIndex
+     * @param {String} name
+     * @param {Boolean} loop
+     * @returns {spine.TrackEntry|null}
+     */
+    setAnimation(trackIndex: number, name: string, loop: boolean): any;
+    /**
+     * 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 {spine.TrackEntry|null}
+     */
+    addAnimation(trackIndex: number, name: string, loop: boolean, delay?: number): any;
+    /**
+     * Find animation with specified name
+     * @param {String} name
+     * @returns {spine.Animation|null}
+     */
+    findAnimation(name: string): any;
+    /**
+     * Returns track entry by trackIndex.
+     * @param trackIndex
+     * @returns {spine.TrackEntry|null}
+     */
+    getCurrent(trackIndex: number): any;
+    /**
+     * Clears all tracks of animation state.
+     */
+    clearTracks(): void;
+    /**
+     * Clears track of animation state by trackIndex.
+     * @param {Number} trackIndex
+     */
+    clearTrack(trackIndex: number): void;
+    /**
+     * 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(dt: number): void;
+    /**
+     * Set the start event listener.
+     * @param {function} listener
+     */
+    setStartListener(listener: any): void;
+    /**
+     * Set the interrupt listener
+     * @param {function} listener
+     */
+    setInterruptListener(listener: any): void;
+    /**
+     * Set the end event listener.
+     * @param {function} listener
+     */
+    setEndListener(listener: any): void;
+    /**
+     * Set the dispose listener
+     * @param {function} listener
+     */
+    setDisposeListener(listener: any): void;
+    setCompleteListener(listener: any): void;
+    setEventListener(listener: any): void;
+    setTrackStartListener(entry: any, listener: any): void;
+    setTrackInterruptListener(entry: any, listener: any): void;
+    setTrackEndListener(entry: any, listener: any): void;
+    setTrackDisposeListener(entry: any, listener: any): void;
+    setTrackCompleteListener(entry: any, listener: any): void;
+    setTrackEventListener(entry: any, listener: any): void;
+    getState(): any;
+    /**
+     * 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]
+     * @returns {SkeletonAnimation}
+     */
+    static createWithJsonFile(skeletonDataFile: any, atlasFile: any, scale?: number): SkeletonAnimation;
+    static create(skeletonDataFile: any, atlasFile: any, scale?: number): SkeletonAnimation;
+}
+//# 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":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;8EAwB8E;AAE9E,eAAO,MAAM,YAAY;;;;;CAaxB,CAAA;AAkGD;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,QAAQ;IAC7C,MAAM,EAAE,GAAG,CAAO;IAClB,uBAAuB,UAAQ;IAC/B,SAAS,EAAE,GAAG,CAAO;gBAET,gBAAgB,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,MAAM;IAMnE;;;OAGG;IACH,qBAAqB,CAAC,SAAS,EAAE,GAAG;IAOpC;;;;;OAKG;IACH,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAInE;;;;OAIG;IACH,oBAAoB,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG;IAM/C;;;;;;OAMG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;IAS5D;;;;;;;OAOG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM;IAU5E;;;;OAIG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM;IAI1B;;;;OAIG;IACH,UAAU,CAAC,UAAU,EAAE,MAAM;IAI7B;;OAEG;IACH,WAAW;IAIX;;;OAGG;IACH,UAAU,CAAC,UAAU,EAAE,MAAM;IAI7B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM;IAUjB;;;OAGG;IACH,gBAAgB,CAAC,QAAQ,EAAE,GAAG;IAI9B;;;OAGG;IACH,oBAAoB,CAAC,QAAQ,EAAE,GAAG;IAIlC;;;OAGG;IACH,cAAc,CAAC,QAAQ,EAAE,GAAG;IAI5B;;;OAGG;IACH,kBAAkB,CAAC,QAAQ,EAAE,GAAG;IAIhC,mBAAmB,CAAC,QAAQ,EAAE,GAAG;IAIjC,gBAAgB,CAAC,QAAQ,EAAE,GAAG;IAI9B,qBAAqB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG;IAI/C,yBAAyB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG;IAInD,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG;IAI7C,uBAAuB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG;IAIjD,wBAAwB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG;IAIlD,qBAAqB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG;IAI/C,QAAQ;IAIR;;;;;;;OAOG;IACH,MAAM,CAAC,kBAAkB,CAAC,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,MAAM;IAI/E,MAAM,CAAC,MAAM,CAAC,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,MAAM;CAGpE"}

package/dist/spine/CCSkeletonAnimation.js

@@ -0,0 +1,311 @@
+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.
+ ****************************************************************************/
+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 () { },
+};
+/**
+ * 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}}
+ */
+const ANIMATION_EVENT_TYPE = {
+    START: 0,
+    INTERRUPT: 1,
+    END: 2,
+    DISPOSE: 3,
+    COMPLETE: 4,
+    EVENT: 5,
+};
+const 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 = TrackEntryListeners.prototype;
+proto.start = function (trackEntry) {
+    if (this.startListener) {
+        this.startListener(trackEntry);
+    }
+    if (this.callback) {
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, 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, 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, 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, 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, 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, ANIMATION_EVENT_TYPE.EVENT, event, 0);
+    }
+};
+TrackEntryListeners.getListeners = function (entry) {
+    if (!entry.listener) {
+        entry.listener = new TrackEntryListeners();
+    }
+    return entry.listener;
+};
+/**
+ * The skeleton animation of spine. It updates animation's state and skeleton's world transform.
+ * @class
+ * @extends Skeleton
+ */
+export class SkeletonAnimation extends Skeleton {
+    _state = null;
+    _ownsAnimationStateData = false;
+    _listener = null;
+    constructor(skeletonDataFile, atlasFile, scale) {
+        super(skeletonDataFile, atlasFile, scale);
+        this._ownsAnimationStateData = true;
+        this.setAnimationStateData(new spine.AnimationStateData(this._skeleton.data));
+    }
+    /**
+     * Sets animation state data to SkeletonAnimation.
+     * @param {spine.AnimationStateData} stateData
+     */
+    setAnimationStateData(stateData) {
+        const state = new spine.AnimationState(stateData);
+        this._listener = new TrackEntryListeners();
+        state.addListener(this._listener);
+        this._state = state;
+    }
+    /**
+     * Mix applies all keyframe values, interpolated for the specified time and mixed with the current values.
+     * @param {String} fromAnimation
+     * @param {String} toAnimation
+     * @param {Number} duration
+     */
+    setMix(fromAnimation, toAnimation, duration) {
+        this._state.data.setMixWith(fromAnimation, toAnimation, duration);
+    }
+    /**
+     * Sets event listener of SkeletonAnimation.
+     * @param {Object} target
+     * @param {Function} callback
+     */
+    setAnimationListener(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 {spine.TrackEntry|null}
+     */
+    setAnimation(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 {spine.TrackEntry|null}
+     */
+    addAnimation(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 {spine.Animation|null}
+     */
+    findAnimation(name) {
+        return this._skeleton.data.findAnimation(name);
+    }
+    /**
+     * Returns track entry by trackIndex.
+     * @param trackIndex
+     * @returns {spine.TrackEntry|null}
+     */
+    getCurrent(trackIndex) {
+        return this._state.getCurrent(trackIndex);
+    }
+    /**
+     * Clears all tracks of animation state.
+     */
+    clearTracks() {
+        this._state.clearTracks();
+    }
+    /**
+     * Clears track of animation state by trackIndex.
+     * @param {Number} trackIndex
+     */
+    clearTrack(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(dt) {
+        super.update(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(listener) {
+        this._listener.startListener = listener;
+    }
+    /**
+     * Set the interrupt listener
+     * @param {function} listener
+     */
+    setInterruptListener(listener) {
+        this._listener.interruptListener = listener;
+    }
+    /**
+     * Set the end event listener.
+     * @param {function} listener
+     */
+    setEndListener(listener) {
+        this._listener.endListener = listener;
+    }
+    /**
+     * Set the dispose listener
+     * @param {function} listener
+     */
+    setDisposeListener(listener) {
+        this._listener.disposeListener = listener;
+    }
+    setCompleteListener(listener) {
+        this._listener.completeListener = listener;
+    }
+    setEventListener(listener) {
+        this._listener.eventListener = listener;
+    }
+    setTrackStartListener(entry, listener) {
+        TrackEntryListeners.getListeners(entry).startListener = listener;
+    }
+    setTrackInterruptListener(entry, listener) {
+        TrackEntryListeners.getListeners(entry).interruptListener = listener;
+    }
+    setTrackEndListener(entry, listener) {
+        TrackEntryListeners.getListeners(entry).endListener = listener;
+    }
+    setTrackDisposeListener(entry, listener) {
+        TrackEntryListeners.getListeners(entry).disposeListener = listener;
+    }
+    setTrackCompleteListener(entry, listener) {
+        TrackEntryListeners.getListeners(entry).completeListener = listener;
+    }
+    setTrackEventListener(entry, listener) {
+        TrackEntryListeners.getListeners(entry).eventListener = listener;
+    }
+    getState() {
+        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]
+     * @returns {SkeletonAnimation}
+     */
+    static createWithJsonFile(skeletonDataFile, atlasFile, scale) {
+        return new SkeletonAnimation(skeletonDataFile, atlasFile, scale);
+    }
+    static create(skeletonDataFile, atlasFile, 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":"AA2PA,eAAO,MAAM,eAAe,KAAyB,CAAA"}