@safe-engine/cocos 1.0.1

package/dist/spine/CCSkeletonAnimation.js

@@ -0,0 +1,353 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkeletonAnimation = exports._atlasLoader = void 0;
+var spine = __importStar(require("@esotericsoftware/spine-core"));
+var CCSkeleton_1 = require("./CCSkeleton");
+var CCSkeletonTexture_1 = require("./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 || {};
+exports._atlasLoader = {
+    spAtlasFile: null,
+    setAtlasFile: function (spAtlasFile) {
+        this.spAtlasFile = spAtlasFile;
+    },
+    load: function (line) {
+        var texturePath = cc.path.join(cc.path.dirname(this.spAtlasFile), line);
+        var texture = cc.textureCache.addImage(texturePath);
+        var tex = new CCSkeletonTexture_1.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;
+};
+var 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) {
+    var 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);
+ */
+exports.SkeletonAnimation = CCSkeleton_1.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 () {
+        CCSkeleton_1.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) {
+        var 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) {
+        var animation = this._skeleton.data.findAnimation(name);
+        if (!animation) {
+            cc.log("Spine: Animation not found: ".concat(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;
+        var animation = this._skeleton.data.findAnimation(name);
+        if (!animation) {
+            cc.log("Spine: Animation not found:".concat(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}
+ */
+exports.SkeletonAnimation.createWithJsonFile = exports.SkeletonAnimation.create = function (skeletonDataFile, atlasFile /* or atlas*/, scale) {
+    return new exports.SkeletonAnimation(skeletonDataFile, atlasFile, scale);
+};

package/dist/spine/CCSkeletonCanvasRenderCmd.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# 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":""}

package/dist/spine/CCSkeletonCanvasRenderCmd.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var spine_core_1 = __importDefault(require("@esotericsoftware/spine-core"));
+/****************************************************************************
+ 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.
+ ****************************************************************************/
+var gworld = gworld || {};
+(function () {
+    gworld.Skeleton.CanvasRenderCmd = function (renderableObject) {
+        this._rootCtor(renderableObject);
+        this._needDraw = true;
+    };
+    var proto = (gworld.Skeleton.CanvasRenderCmd.prototype = Object.create(cc.Node.CanvasRenderCmd.prototype));
+    proto.constructor = gworld.Skeleton.CanvasRenderCmd;
+    proto.rendering = function (wrapper, scaleX, scaleY) {
+        var node = this._node, i, n, slot, slotNode;
+        wrapper = wrapper || cc._renderContext;
+        var 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);
+        var attachment, drawingUtil = cc._drawingUtil;
+        if (node._debugSlots) {
+            // Slots.
+            drawingUtil.setDrawColor(0, 0, 255, 255);
+            drawingUtil.setLineWidth(1);
+            var points = [];
+            for (i = 0, n = locSkeleton.slots.length; i < n; i++) {
+                slot = locSkeleton.drawOrder[i];
+                if (!slot.attachment || !(slot.attachment instanceof spine_core_1.default.RegionAttachment))
+                    continue;
+                attachment = slot.attachment;
+                this._updateRegionAttachmentSlot(attachment, slot, points);
+                drawingUtil.drawPoly(points, 4, true);
+            }
+        }
+        if (node._debugBones) {
+            // Bone lengths.
+            var bone = void 0;
+            drawingUtil.setLineWidth(2);
+            drawingUtil.setDrawColor(255, 0, 0, 255);
+            for (i = 0, n = locSkeleton.bones.length; i < n; i++) {
+                bone = locSkeleton.bones[i];
+                var x = bone.data.length * bone.a + bone.worldX;
+                var y = bone.data.length * bone.c + bone.worldY;
+                drawingUtil.drawLine({ x: bone.worldX, y: bone.worldY }, { x: x, y: y });
+            }
+            // Bone origins.
+            var 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;
+        var vertices = spine_core_1.default.Utils.setArraySize([], 8, 0);
+        attachment.computeWorldVertices(slot, vertices, 0, 2);
+        var VERTEX = spine_core_1.default.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 () {
+        var node = this._node;
+        var locSkeleton = node._skeleton, spriteName, sprite;
+        for (var i = 0, n = locSkeleton.slots.length; i < n; i++) {
+            var slot = locSkeleton.slots[i], attachment = slot.attachment;
+            var slotNode = new cc.Node();
+            slot._slotNode = slotNode;
+            if (attachment instanceof spine_core_1.default.RegionAttachment) {
+                spriteName = attachment.name;
+                sprite = this._createSprite(slot, attachment);
+                slot.currentSprite = sprite;
+                slot.currentSpriteName = spriteName;
+                slotNode.addChild(sprite);
+            }
+            else if (attachment instanceof spine_core_1.default.MeshAttachment) {
+                //todo for mesh
+            }
+        }
+    };
+    var loaded = function (sprite, texture, attachment) {
+        var rendererObject = attachment.region;
+        var 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) {
+        var rendererObject = attachment.region;
+        var texture = rendererObject.texture.getRealTexture();
+        var 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 () {
+        var locSkeleton = this._node._skeleton, slots = locSkeleton.slots;
+        var color = this._displayedColor, opacity = this._displayedOpacity;
+        var i, n, selSprite, ax, ay;
+        var 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 spine_core_1.default.RegionAttachment) {
+                if (attachment.region) {
+                    if (!slot.currentSpriteName || slot.currentSpriteName !== attachment.name) {
+                        var 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 {
+                            var sprite = this._createSprite(slot, attachment);
+                            slotNode.addChild(sprite);
+                        }
+                        slot.currentSprite = slot.sprites[spriteName];
+                        slot.currentSpriteName = spriteName;
+                    }
+                }
+                var 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);
+                var 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 spine_core_1.default.MeshAttachment) {
+                // Can not render mesh
+            }
+            else {
+                slotNode.setVisible(false);
+                continue;
+            }
+            slotNode.setVisible(true);
+        }
+    };
+})();

package/dist/spine/CCSkeletonTexture.d.ts

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

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

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