@safe-engine/cocos 1.9.6 → 1.10.2

package/dist/spine/CCSkeletonAnimation.js

@@ -26,7 +26,6 @@ import { SkeletonTexture } from './CCSkeletonTexture';
  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) {
@@ -39,14 +38,14 @@ export const _atlasLoader = {
         tex.setRealTexture(texture);
         return tex;
     },
-    unload: function (obj) { },
+    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}}
  */
-gworld.ANIMATION_EVENT_TYPE = {
+const ANIMATION_EVENT_TYPE = {
     START: 0,
     INTERRUPT: 1,
     END: 2,
@@ -54,7 +53,7 @@ gworld.ANIMATION_EVENT_TYPE = {
     COMPLETE: 4,
     EVENT: 5,
 };
-gworld.TrackEntryListeners = function (startListener, endListener, completeListener, eventListener, interruptListener, disposeListener) {
+const TrackEntryListeners = function (startListener, endListener, completeListener, eventListener, interruptListener, disposeListener) {
     this.startListener = startListener || null;
     this.endListener = endListener || null;
     this.completeListener = completeListener || null;
@@ -65,13 +64,13 @@ gworld.TrackEntryListeners = function (startListener, endListener, completeListe
     this.callbackTarget = null;
     this.skeletonNode = null;
 };
-const proto = gworld.TrackEntryListeners.prototype;
+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, gworld.ANIMATION_EVENT_TYPE.START, null, 0);
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.START, null, 0);
     }
 };
 proto.interrupt = function (trackEntry) {
@@ -79,7 +78,7 @@ proto.interrupt = function (trackEntry) {
         this.interruptListener(trackEntry);
     }
     if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.INTERRUPT, null, 0);
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.INTERRUPT, null, 0);
     }
 };
 proto.end = function (trackEntry) {
@@ -87,7 +86,7 @@ proto.end = function (trackEntry) {
         this.endListener(trackEntry);
     }
     if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.END, null, 0);
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.END, null, 0);
     }
 };
 proto.dispose = function (trackEntry) {
@@ -95,7 +94,7 @@ proto.dispose = function (trackEntry) {
         this.disposeListener(trackEntry);
     }
     if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.DISPOSE, null, 0);
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.DISPOSE, null, 0);
     }
 };
 proto.complete = function (trackEntry) {
@@ -104,7 +103,7 @@ proto.complete = function (trackEntry) {
         this.completeListener(trackEntry, loopCount);
     }
     if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.COMPLETE, null, loopCount);
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.COMPLETE, null, loopCount);
     }
 };
 proto.event = function (trackEntry, event) {
@@ -112,90 +111,82 @@ proto.event = function (trackEntry, event) {
         this.eventListener(trackEntry, event);
     }
     if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, gworld.ANIMATION_EVENT_TYPE.EVENT, event, 0);
+        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.EVENT, event, 0);
     }
 };
-gworld.TrackEntryListeners.getListeners = function (entry) {
+TrackEntryListeners.getListeners = function (entry) {
     if (!entry.listener) {
-        entry.listener = new gworld.TrackEntryListeners();
+        entry.listener = new 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);
+ * @extends Skeleton
  */
-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);
+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 {gworld.spine.AnimationStateData} stateData
+     * @param {spine.AnimationStateData} stateData
      */
-    setAnimationStateData: function (stateData) {
+    setAnimationStateData(stateData) {
         const state = new spine.AnimationState(stateData);
-        this._listener = new gworld.TrackEntryListeners();
-        // state.rendererObject = this;
+        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.  <br/>
+     * 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: function (fromAnimation, toAnimation, duration) {
+    setMix(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) {
+    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 {gworld.spine.TrackEntry|null}
+     * @returns {spine.TrackEntry|null}
      */
-    setAnimation: function (trackIndex, name, loop) {
+    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 {gworld.spine.TrackEntry|null}
+     * @returns {spine.TrackEntry|null}
      */
-    addAnimation: function (trackIndex, name, loop, delay) {
+    addAnimation(trackIndex, name, loop, delay) {
         delay = delay == null ? 0 : delay;
         const animation = this._skeleton.data.findAnimation(name);
         if (!animation) {
@@ -203,115 +194,118 @@ export const SkeletonAnimation = Skeleton.extend({
             return null;
         }
         return this._state.addAnimationWith(trackIndex, animation, loop, delay);
-    },
+    }
     /**
      * Find animation with specified name
      * @param {String} name
-     * @returns {gworld.spine.Animation|null}
+     * @returns {spine.Animation|null}
      */
-    findAnimation: function (name) {
+    findAnimation(name) {
         return this._skeleton.data.findAnimation(name);
-    },
+    }
     /**
      * Returns track entry by trackIndex.
      * @param trackIndex
-     * @returns {gworld.spine.TrackEntry|null}
+     * @returns {spine.TrackEntry|null}
      */
-    getCurrent: function (trackIndex) {
+    getCurrent(trackIndex) {
         return this._state.getCurrent(trackIndex);
-    },
+    }
     /**
      * Clears all tracks of animation state.
      */
-    clearTracks: function () {
+    clearTracks() {
         this._state.clearTracks();
-    },
+    }
     /**
      * Clears track of animation state by trackIndex.
      * @param {Number} trackIndex
      */
-    clearTrack: function (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: function (dt) {
-        this._super(dt);
+    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: function (listener) {
+    setStartListener(listener) {
         this._listener.startListener = listener;
-    },
+    }
     /**
      * Set the interrupt listener
      * @param {function} listener
      */
-    setInterruptListener: function (listener) {
+    setInterruptListener(listener) {
         this._listener.interruptListener = listener;
-    },
+    }
     /**
      * Set the end event listener.
      * @param {function} listener
      */
-    setEndListener: function (listener) {
+    setEndListener(listener) {
         this._listener.endListener = listener;
-    },
+    }
     /**
      * Set the dispose listener
      * @param {function} listener
      */
-    setDisposeListener: function (listener) {
+    setDisposeListener(listener) {
         this._listener.disposeListener = listener;
-    },
-    setCompleteListener: function (listener) {
+    }
+    setCompleteListener(listener) {
         this._listener.completeListener = listener;
-    },
-    setEventListener: function (listener) {
+    }
+    setEventListener(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 () {
+    }
+    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] 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);
-};
+    }
+    /**
+     * 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.map

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

package/dist/spine/CCSkeletonCanvasRenderCmd.js

@@ -31,7 +31,8 @@ var gworld = gworld || {};
     const proto = (gworld.CanvasRenderCmd.prototype = Object.create(cc.Node.CanvasRenderCmd.prototype));
     proto.constructor = gworld.CanvasRenderCmd;
     proto.rendering = function (wrapper, scaleX, scaleY) {
-        let node = this._node, i, n, slot, slotNode;
+        const node = this._node;
+        let i, n, slot, slotNode;
         wrapper = wrapper || cc._renderContext;
         const locSkeleton = node._skeleton, drawOrder = locSkeleton.drawOrder;
         for (i = 0, n = drawOrder.length; i < n; i++) {
@@ -47,7 +48,8 @@ var gworld = gworld || {};
             return;
         wrapper.setTransform(this._worldTransform, scaleX, scaleY);
         wrapper.setGlobalAlpha(1);
-        let attachment, drawingUtil = cc._drawingUtil;
+        let attachment;
+        const drawingUtil = cc._drawingUtil;
         if (node._debugSlots) {
             // Slots.
             drawingUtil.setDrawColor(0, 0, 255, 255);
@@ -107,7 +109,8 @@ var gworld = gworld || {};
     };
     proto._createChildFormSkeletonData = function () {
         const node = this._node;
-        let locSkeleton = node._skeleton, spriteName, sprite;
+        const locSkeleton = node._skeleton;
+        let spriteName, sprite;
         for (let i = 0, n = locSkeleton.slots.length; i < n; i++) {
             const slot = locSkeleton.slots[i], attachment = slot.attachment;
             const slotNode = new cc.Node();

package/dist/spine/CCSkeletonTexture.d.ts

@@ -1,2 +1,25 @@
-export declare const SkeletonTexture: any;
+/****************************************************************************
+ Copyright (c) 2017 Chukong Technologies Inc.
+
+ 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 SkeletonTexture: (image: any) => void;
 //# sourceMappingURL=CCSkeletonTexture.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CCSkeletonTexture.d.ts","sourceRoot":"","sources":["../../src/spine/CCSkeletonTexture.ts"],"names":[],"mappings":"AAoEA,eAAO,MAAM,eAAe,KAAyB,CAAA"}
+{"version":3,"file":"CCSkeletonTexture.d.ts","sourceRoot":"","sources":["../../src/spine/CCSkeletonTexture.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;8EAsB8E;AAE9E,eAAO,MAAM,eAAe,GAAa,UAAK,SAE7C,CAAA"}

package/dist/spine/CCSkeletonTexture.js

@@ -22,12 +22,11 @@ import * as spine from '@esotericsoftware/spine-core';
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ****************************************************************************/
-var gworld = gworld || {};
-gworld.SkeletonTexture = function (image) {
-    // spine.Texture.call(this, image);
+export const SkeletonTexture = function (image) {
+    // spine.Texture.call(this, image)
 };
-cc.inherits(gworld.SkeletonTexture, spine.Texture);
-cc.extend(gworld.SkeletonTexture.prototype, {
+cc.inherits(SkeletonTexture, spine.Texture);
+cc.extend(SkeletonTexture.prototype, {
     name: 'gworld.SkeletonTexture',
     _texture: null,
     setRealTexture: function (tex) {
@@ -59,4 +58,3 @@ cc.extend(gworld.SkeletonTexture.prototype, {
         }
     },
 });
-export const SkeletonTexture = gworld.SkeletonTexture;

package/dist/spine/CCSkeletonWebGLRenderCmd.d.ts

@@ -1,2 +1,28 @@
-export declare const WebGLRenderCmd: any;
+/****************************************************************************
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ 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 WebGLRenderCmd: {
+    (renderableObject: any): void;
+    prototype: any;
+};
 //# sourceMappingURL=CCSkeletonWebGLRenderCmd.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CCSkeletonWebGLRenderCmd.d.ts","sourceRoot":"","sources":["../../src/spine/CCSkeletonWebGLRenderCmd.ts"],"names":[],"mappings":"AAyWA,eAAO,MAAM,cAAc,KAAwB,CAAA"}
+{"version":3,"file":"CCSkeletonWebGLRenderCmd.d.ts","sourceRoot":"","sources":["../../src/spine/CCSkeletonWebGLRenderCmd.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;8EAsB8E;AAE9E,eAAO,MAAM,cAAc;;;CAS1B,CAAA"}