@safe-engine/cocos 2.2.8 → 2.3.4

package/dist/spine/spine-cocos/CCSkeletonAnimation.d.ts

@@ -0,0 +1,87 @@
+import { Animation, AnimationState, AnimationStateData } from '@esotericsoftware/spine-core';
+import { CCSkeleton } 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 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}}
+ */
+export declare const ANIMATION_EVENT_TYPE: {
+    START: number;
+    INTERRUPT: number;
+    END: number;
+    DISPOSE: number;
+    COMPLETE: number;
+    EVENT: number;
+};
+export declare const TrackEntryListeners: {
+    (startListener?: any, endListener?: any, completeListener?: any, eventListener?: any, interruptListener?: any, disposeListener?: any): void;
+    getListeners(entry: any): any;
+};
+/**
+ * The skeleton animation of  It updates animation's state and skeleton's world transform.
+ * @class
+ * @extends Skeleton
+ * @example
+ * var spineBoy = new SkeletonAnimation('res/skeletons/spineboy.json', 'res/skeletons/spineboy.atlas');
+ * this.addChild(spineBoy, 4);
+ */
+export declare class SkeletonAnimation extends CCSkeleton {
+    init(): boolean;
+    setAnimationStateData(stateData: AnimationStateData): void;
+    setMix(fromAnimation: Animation, toAnimation: Animation, duration: number): void;
+    setAnimationListener(target: any, callback: Function): void;
+    setAnimation(trackIndex: number, name: string, loop: boolean): import("@esotericsoftware/spine-core").TrackEntry;
+    addAnimation(trackIndex: number, name: string, loop: boolean, delay?: number): import("@esotericsoftware/spine-core").TrackEntry;
+    findAnimation(name: string): Animation;
+    getCurrent(trackIndex: number): import("@esotericsoftware/spine-core").TrackEntry;
+    clearTracks(): void;
+    clearTrack(trackIndex: number): void;
+    update(dt: number): void;
+    setStartListener(listener: Function): void;
+    setInterruptListener(listener: Function): void;
+    setEndListener(listener: Function): void;
+    setDisposeListener(listener: Function): void;
+    setCompleteListener(listener: Function): void;
+    setEventListener(listener: Function): void;
+    setTrackStartListener(entry: any, listener: Function): void;
+    setTrackInterruptListener(entry: any, listener: Function): void;
+    setTrackEndListener(entry: any, listener: Function): void;
+    setTrackDisposeListener(entry: any, listener: Function): void;
+    setTrackCompleteListener(entry: any, listener: Function): void;
+    setTrackEventListener(entry: any, listener: Function): void;
+    getState(): AnimationState;
+    static createWithJsonFile(skeletonDataFile: any, atlasFile: any, scale?: any): SkeletonAnimation;
+    static createWithBinaryFile(skeletonDataFile: any, atlasFile: any, scale?: any): SkeletonAnimation;
+}
+//# sourceMappingURL=CCSkeletonAnimation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CCSkeletonAnimation.d.ts","sourceRoot":"","sources":["../../../src/spine/spine-cocos/CCSkeletonAnimation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,cAAc,EACd,kBAAkB,EAKnB,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;8EAwB8E;AAE9E,eAAO,MAAM,YAAY;;;;;CAaxB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;CAOhC,CAAA;AAED,eAAO,MAAM,mBAAmB;;;CAiB/B,CAAA;AAiED;;;;;;;GAOG;AAEH,qBAAa,iBAAkB,SAAQ,UAAU;IAC/C,IAAI,IAAI,OAAO;IAOf,qBAAqB,CAAC,SAAS,EAAE,kBAAkB;IAOnD,MAAM,CAAC,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM;IAIzE,oBAAoB,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ;IAMpD,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;IAS5D,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM;IAU5E,aAAa,CAAC,IAAI,EAAE,MAAM;IAI1B,UAAU,CAAC,UAAU,EAAE,MAAM;IAI7B,WAAW;IAIX,UAAU,CAAC,UAAU,EAAE,MAAM;IAI7B,MAAM,CAAC,EAAE,EAAE,MAAM;IAcjB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ;IAInC,oBAAoB,CAAC,QAAQ,EAAE,QAAQ;IAIvC,cAAc,CAAC,QAAQ,EAAE,QAAQ;IAIjC,kBAAkB,CAAC,QAAQ,EAAE,QAAQ;IAIrC,mBAAmB,CAAC,QAAQ,EAAE,QAAQ;IAItC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ;IAInC,qBAAqB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ;IAIpD,yBAAyB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ;IAIxD,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ;IAIlD,uBAAuB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ;IAItD,wBAAwB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ;IAIvD,qBAAqB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ;IAIpD,QAAQ;IAIR,MAAM,CAAC,kBAAkB,CAAC,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,GAAG;IAI5E,MAAM,CAAC,oBAAoB,CAAC,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,GAAG;CAc/E"}

package/dist/spine/{CCSkeletonAnimation.js → spine-cocos/CCSkeletonAnimation.js}

@@ -1,5 +1,6 @@
-import * as spine from '@esotericsoftware/spine-core';
-import { Skeleton } from './CCSkeleton';
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+import { AnimationState, AnimationStateData, AtlasAttachmentLoader, Physics, SkeletonBinary, TextureAtlas, } from '@esotericsoftware/spine-core';
+import { CCSkeleton } from './CCSkeleton';
 import { SkeletonTexture } from './CCSkeletonTexture';
 /****************************************************************************
  Copyright (c) 2011-2012 cocos2d-x.org
@@ -34,7 +35,7 @@ export const _atlasLoader = {
     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() });
+        const tex = new SkeletonTexture();
         tex.setRealTexture(texture);
         return tex;
     },
@@ -45,7 +46,7 @@ export const _atlasLoader = {
  * @constant
  * @type {{START: number, END: number, COMPLETE: number, EVENT: number}}
  */
-const ANIMATION_EVENT_TYPE = {
+export const ANIMATION_EVENT_TYPE = {
     START: 0,
     INTERRUPT: 1,
     END: 2,
@@ -53,7 +54,7 @@ const ANIMATION_EVENT_TYPE = {
     COMPLETE: 4,
     EVENT: 5,
 };
-const TrackEntryListeners = function (startListener, endListener, completeListener, eventListener, interruptListener, disposeListener) {
+export const TrackEntryListeners = function (startListener, endListener, completeListener, eventListener, interruptListener, disposeListener) {
     this.startListener = startListener || null;
     this.endListener = endListener || null;
     this.completeListener = completeListener || null;
@@ -121,71 +122,42 @@ TrackEntryListeners.getListeners = function (entry) {
     return entry.listener;
 };
 /**
- * The skeleton animation of spine. It updates animation's state and skeleton's world transform.
+ * The skeleton animation of  It updates animation's state and skeleton's world transform.
  * @class
  * @extends Skeleton
+ * @example
+ * var spineBoy = new SkeletonAnimation('res/skeletons/spineboy.json', 'res/skeletons/spineboy.atlas');
+ * this.addChild(spineBoy, 4);
  */
-export class SkeletonAnimation extends Skeleton {
-    _state = null;
-    _ownsAnimationStateData = false;
-    _listener = null;
-    constructor(skeletonDataFile, atlasFile, scale) {
-        super(skeletonDataFile, atlasFile, scale);
+export class SkeletonAnimation extends CCSkeleton {
+    init() {
+        super.init();
         this._ownsAnimationStateData = true;
-        this.setAnimationStateData(new spine.AnimationStateData(this._skeleton.data));
+        this.setAnimationStateData(new AnimationStateData(this._skeleton.data));
+        return true;
     }
-    /**
-     * Sets animation state data to SkeletonAnimation.
-     * @param {spine.AnimationStateData} stateData
-     */
     setAnimationStateData(stateData) {
-        const state = new spine.AnimationState(stateData);
+        const state = new 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}`);
+            cc.log(`Spine: Animation not found: ${name}/${this._skeleton.data.animations.map((a) => a.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);
@@ -195,75 +167,40 @@ export class SkeletonAnimation extends Skeleton {
         }
         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);
+        if (this._renderCmd && typeof this._renderCmd.setDirtyFlag === 'function') {
+            this._renderCmd.setDirtyFlag(cc.Node._dirtyFlags.contentDirty);
+        }
         this._state.update(dt);
         this._state.apply(this._skeleton);
-        this._skeleton.updateWorldTransform(true);
-        this._renderCmd._updateChild();
+        this._skeleton.updateWorldTransform(Physics.pose);
+        if (this._renderCmd && typeof this._renderCmd._updateChild === 'function') {
+            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;
     }
@@ -294,18 +231,21 @@ export class SkeletonAnimation extends Skeleton {
     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);
+    static createWithBinaryFile(skeletonDataFile, atlasFile, scale) {
+        const dataTex = cc.loader.getRes(atlasFile);
+        _atlasLoader.setAtlasFile(atlasFile);
+        const atlas = new TextureAtlas(dataTex);
+        for (const page of atlas.pages) {
+            const texture = _atlasLoader.load(page.name);
+            page.setTexture(texture);
+        }
+        const attachmentLoader = new AtlasAttachmentLoader(atlas);
+        const skeletonBinaryReader = new SkeletonBinary(attachmentLoader);
+        const skeletonBinary = cc.loader.getRes(skeletonDataFile);
+        const skeletonData = skeletonBinaryReader.readSkeletonData(skeletonBinary);
+        return new SkeletonAnimation(skeletonData, true, scale);
     }
 }

package/dist/spine/spine-cocos/CCSkeletonCanvasRenderCmd.d.ts

@@ -0,0 +1,28 @@
+/****************************************************************************
+ 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 CanvasRenderCmd: {
+    (renderableObject: any): void;
+    prototype: any;
+};
+//# sourceMappingURL=CCSkeletonCanvasRenderCmd.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CCSkeletonCanvasRenderCmd.d.ts","sourceRoot":"","sources":["../../../src/spine/spine-cocos/CCSkeletonCanvasRenderCmd.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;8EAsB8E;AAI9E,eAAO,MAAM,eAAe;;;CAG3B,CAAA"}

package/dist/spine/spine-cocos/CCSkeletonCanvasRenderCmd.js

@@ -0,0 +1,224 @@
+/****************************************************************************
+ 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.
+ ****************************************************************************/
+import { MeshAttachment, RegionAttachment, Utils } from '@esotericsoftware/spine-core';
+export const CanvasRenderCmd = function (renderableObject) {
+    this._rootCtor(renderableObject);
+    this._needDraw = true;
+};
+const proto = (CanvasRenderCmd.prototype = Object.create(cc.Node.CanvasRenderCmd.prototype));
+proto.constructor = CanvasRenderCmd;
+proto.rendering = function (wrapper, scaleX, scaleY) {
+    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++) {
+        slot = drawOrder[i];
+        slotNode = slot._slotNode;
+        if (slotNode._visible && slotNode._renderCmd && slot.currentSprite) {
+            slotNode._renderCmd.transform(this, true);
+            slot.currentSprite._renderCmd.rendering(wrapper, scaleX, scaleY);
+            slotNode._renderCmd._dirtyFlag = slot.currentSprite._renderCmd._dirtyFlag = 0;
+        }
+    }
+    if (!node._debugSlots && !node._debugBones)
+        return;
+    wrapper.setTransform(this._worldTransform, scaleX, scaleY);
+    wrapper.setGlobalAlpha(1);
+    let attachment;
+    const drawingUtil = cc._drawingUtil;
+    if (node._debugSlots) {
+        // Slots.
+        drawingUtil.setDrawColor(0, 0, 255, 255);
+        drawingUtil.setLineWidth(1);
+        const points = [];
+        for (i = 0, n = locSkeleton.slots.length; i < n; i++) {
+            slot = locSkeleton.drawOrder[i];
+            if (!slot.attachment || !(slot.attachment instanceof RegionAttachment))
+                continue;
+            attachment = slot.attachment;
+            this._updateRegionAttachmentSlot(attachment, slot, points);
+            drawingUtil.drawPoly(points, 4, true);
+        }
+    }
+    if (node._debugBones) {
+        // Bone lengths.
+        let bone;
+        drawingUtil.setLineWidth(2);
+        drawingUtil.setDrawColor(255, 0, 0, 255);
+        for (i = 0, n = locSkeleton.bones.length; i < n; i++) {
+            bone = locSkeleton.bones[i];
+            const x = bone.data.length * bone.a + bone.worldX;
+            const y = bone.data.length * bone.c + bone.worldY;
+            drawingUtil.drawLine({ x: bone.worldX, y: bone.worldY }, { x: x, y: y });
+        }
+        // Bone origins.
+        const pointSize = 4;
+        drawingUtil.setDrawColor(0, 0, 255, 255); // Root bone is blue.
+        for (i = 0, n = locSkeleton.bones.length; i < n; i++) {
+            bone = locSkeleton.bones[i];
+            drawingUtil.drawPoint({ x: bone.worldX, y: bone.worldY }, pointSize);
+            if (i === 0)
+                drawingUtil.setDrawColor(0, 255, 0, 255);
+        }
+    }
+};
+proto.updateStatus = function () {
+    this.originUpdateStatus();
+    this._updateCurrentRegions();
+    this._regionFlag = cc.Node.CanvasRenderCmd.RegionStatus.DirtyDouble;
+    this._dirtyFlag &= ~cc.Node._dirtyFlags.contentDirty;
+};
+proto.getLocalBB = function () {
+    return this._node.getBoundingBox();
+};
+proto._updateRegionAttachmentSlot = function (attachment, slot, points) {
+    if (!points)
+        return;
+    const vertices = Utils.setArraySize([], 8, 0);
+    attachment.computeWorldVertices(slot, vertices, 0, 2);
+    const VERTEX = RegionAttachment;
+    points.length = 0;
+    points.push(cc.p(vertices[VERTEX.X1], vertices[VERTEX.Y1]));
+    points.push(cc.p(vertices[VERTEX.X4], vertices[VERTEX.Y4]));
+    points.push(cc.p(vertices[VERTEX.X3], vertices[VERTEX.Y3]));
+    points.push(cc.p(vertices[VERTEX.X2], vertices[VERTEX.Y2]));
+};
+proto._createChildFormSkeletonData = function () {
+    const node = this._node;
+    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();
+        slot._slotNode = slotNode;
+        if (attachment instanceof RegionAttachment) {
+            spriteName = attachment.name;
+            sprite = this._createSprite(slot, attachment);
+            slot.currentSprite = sprite;
+            slot.currentSpriteName = spriteName;
+            slotNode.addChild(sprite);
+        }
+        else if (attachment instanceof MeshAttachment) {
+            //todo for mesh
+        }
+    }
+};
+const loaded = function (sprite, texture, attachment) {
+    const rendererObject = attachment.region;
+    const rect = new cc.Rect(rendererObject.x, rendererObject.y, rendererObject.width, rendererObject.height);
+    sprite.initWithTexture(texture, rect, rendererObject.rotate, false);
+    sprite._rect.width = attachment.width;
+    sprite._rect.height = attachment.height;
+    sprite.setContentSize(attachment.width, attachment.height);
+    sprite.setRotation(-attachment.rotation);
+    sprite.setScale((rendererObject.width / rendererObject.originalWidth) * attachment.scaleX, (rendererObject.height / rendererObject.originalHeight) * attachment.scaleY);
+};
+proto._createSprite = function (slot, attachment) {
+    const rendererObject = attachment.region;
+    const texture = rendererObject.texture.getRealTexture();
+    const sprite = new cc.Sprite();
+    if (texture.isLoaded()) {
+        loaded(sprite, texture, attachment);
+    }
+    else {
+        texture.addEventListener('load', function () {
+            loaded(sprite, texture, attachment);
+        }, this);
+    }
+    slot.sprites = slot.sprites || {};
+    slot.sprites[rendererObject.name] = sprite;
+    return sprite;
+};
+proto._updateChild = function () {
+    const locSkeleton = this._node._skeleton, slots = locSkeleton.slots;
+    const color = this._displayedColor, opacity = this._displayedOpacity;
+    let i, n, selSprite, ax, ay;
+    let slot, attachment, slotNode;
+    for (i = 0, n = slots.length; i < n; i++) {
+        slot = slots[i];
+        attachment = slot.attachment;
+        slotNode = slot._slotNode;
+        if (!attachment) {
+            slotNode.setVisible(false);
+            continue;
+        }
+        if (attachment instanceof RegionAttachment) {
+            if (attachment.region) {
+                if (!slot.currentSpriteName || slot.currentSpriteName !== attachment.name) {
+                    const spriteName = attachment.name;
+                    if (slot.currentSprite !== undefined)
+                        slot.currentSprite.setVisible(false);
+                    slot.sprites = slot.sprites || {};
+                    if (slot.sprites[spriteName] !== undefined)
+                        slot.sprites[spriteName].setVisible(true);
+                    else {
+                        const sprite = this._createSprite(slot, attachment);
+                        slotNode.addChild(sprite);
+                    }
+                    slot.currentSprite = slot.sprites[spriteName];
+                    slot.currentSpriteName = spriteName;
+                }
+            }
+            const bone = slot.bone;
+            if (attachment.region.offsetX === 0 && attachment.region.offsetY === 0) {
+                ax = attachment.x;
+                ay = attachment.y;
+            }
+            else {
+                //var regionScaleX = attachment.width / attachment.regionOriginalWidth * attachment.scaleX;
+                //ax = attachment.x + attachment.regionOffsetX * regionScaleX - (attachment.width * attachment.scaleX - attachment.regionWidth * regionScaleX) / 2;
+                ax = (attachment.offset[0] + attachment.offset[4]) * 0.5;
+                ay = (attachment.offset[1] + attachment.offset[5]) * 0.5;
+            }
+            slotNode.setPosition(bone.worldX + ax * bone.a + ay * bone.b, bone.worldY + ax * bone.c + ay * bone.d);
+            slotNode.setScale(bone.getWorldScaleX(), bone.getWorldScaleY());
+            //set the color and opacity
+            selSprite = slot.currentSprite;
+            selSprite._flippedX = bone.skeleton.flipX;
+            selSprite._flippedY = bone.skeleton.flipY;
+            if (selSprite._flippedY || selSprite._flippedX) {
+                slotNode.setRotation(bone.getWorldRotationX());
+                selSprite.setRotation(attachment.rotation);
+            }
+            else {
+                slotNode.setRotation(-bone.getWorldRotationX());
+                selSprite.setRotation(-attachment.rotation);
+            }
+            //hack for sprite
+            selSprite._renderCmd._displayedOpacity = 0 | (opacity * slot.color.a);
+            const r = 0 | (color.r * slot.color.r), g = 0 | (color.g * slot.color.g), b = 0 | (color.b * slot.color.b);
+            selSprite.setColor(cc.color(r, g, b));
+            selSprite._renderCmd._updateColor();
+        }
+        else if (attachment instanceof MeshAttachment) {
+            // Can not render mesh
+        }
+        else {
+            slotNode.setVisible(false);
+            continue;
+        }
+        slotNode.setVisible(true);
+    }
+};

package/dist/spine/{CCSkeletonTexture.d.ts → spine-cocos/CCSkeletonTexture.d.ts}

@@ -21,5 +21,5 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ****************************************************************************/
-export declare const SkeletonTexture: (image: any) => void;
+export declare const SkeletonTexture: () => void;
 //# sourceMappingURL=CCSkeletonTexture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CCSkeletonTexture.d.ts","sourceRoot":"","sources":["../../../src/spine/spine-cocos/CCSkeletonTexture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;8EAsB8E;AAI9E,eAAO,MAAM,eAAe,YAE3B,CAAA"}

package/dist/spine/{CCSkeletonTexture.js → spine-cocos/CCSkeletonTexture.js}

@@ -1,4 +1,3 @@
-import * as spine from '@esotericsoftware/spine-core';
 /****************************************************************************
  Copyright (c) 2017 Chukong Technologies Inc.
 
@@ -22,12 +21,13 @@ import * as spine from '@esotericsoftware/spine-core';
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ****************************************************************************/
-export const SkeletonTexture = function (image) {
-    // spine.Texture.call(this, image)
+import { Texture } from '@esotericsoftware/spine-core';
+export const SkeletonTexture = function () {
+    // Texture.call(this, image);
 };
-cc.inherits(SkeletonTexture, spine.Texture);
+cc.inherits(SkeletonTexture, Texture);
 cc.extend(SkeletonTexture.prototype, {
-    name: 'gworld.SkeletonTexture',
+    name: 'SkeletonTexture',
     _texture: null,
     setRealTexture: function (tex) {
         this._texture = tex;

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

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