@safe-engine/cocos 2.2.8 → 2.3.5

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

@@ -0,0 +1,251 @@
+/* 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
+ 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}}
+ */
+export const ANIMATION_EVENT_TYPE = {
+    START: 0,
+    INTERRUPT: 1,
+    END: 2,
+    DISPOSE: 3,
+    COMPLETE: 4,
+    EVENT: 5,
+};
+export 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  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 CCSkeleton {
+    init() {
+        super.init();
+        this._ownsAnimationStateData = true;
+        this.setAnimationStateData(new AnimationStateData(this._skeleton.data));
+        return true;
+    }
+    setAnimationStateData(stateData) {
+        const state = new AnimationState(stateData);
+        this._listener = new TrackEntryListeners();
+        state.addListener(this._listener);
+        this._state = state;
+    }
+    setMix(fromAnimation, toAnimation, duration) {
+        this._state.data.setMixWith(fromAnimation, toAnimation, duration);
+    }
+    setAnimationListener(target, callback) {
+        this._listener.callbackTarget = target;
+        this._listener.callback = callback;
+        this._listener.skeletonNode = this;
+    }
+    setAnimation(trackIndex, name, loop) {
+        const animation = this._skeleton.data.findAnimation(name);
+        if (!animation) {
+            cc.log(`Spine: Animation not found: ${name}/${this._skeleton.data.animations.map((a) => a.name)} `);
+            return null;
+        }
+        return this._state.setAnimationWith(trackIndex, animation, loop);
+    }
+    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);
+    }
+    findAnimation(name) {
+        return this._skeleton.data.findAnimation(name);
+    }
+    getCurrent(trackIndex) {
+        return this._state.getCurrent(trackIndex);
+    }
+    clearTracks() {
+        this._state.clearTracks();
+    }
+    clearTrack(trackIndex) {
+        this._state.clearTrack(trackIndex);
+    }
+    update(dt) {
+        super.update(dt);
+        dt *= this._timeScale;
+        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(Physics.pose);
+        if (this._renderCmd && typeof this._renderCmd._updateChild === 'function') {
+            this._renderCmd._updateChild();
+        }
+    }
+    setStartListener(listener) {
+        this._listener.startListener = listener;
+    }
+    setInterruptListener(listener) {
+        this._listener.interruptListener = listener;
+    }
+    setEndListener(listener) {
+        this._listener.endListener = 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;
+    }
+    static createWithJsonFile(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/spine-cocos/CCSkeletonTexture.d.ts

@@ -0,0 +1,36 @@
+/****************************************************************************
+ 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.
+ ****************************************************************************/
+import { Texture } from '@esotericsoftware/spine-core';
+export declare class SkeletonTexture extends Texture {
+    constructor(image: any);
+    name: string;
+    _texture: any;
+    setRealTexture(tex: any): void;
+    getRealTexture(): any;
+    setFilters(minFilter: any, magFilter: any): void;
+    setWraps(uWrap: any, vWrap: any): void;
+    dispose(): void;
+    bind(): 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;AAE9E,OAAO,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAA;AAEtD,qBAAa,eAAgB,SAAQ,OAAO;gBAC9B,KAAK,KAAA;IAGjB,IAAI,SAAoB;IACxB,QAAQ,MAAO;IAEf,cAAc,CAAC,GAAG,KAAA;IAIlB,cAAc;IAId,UAAU,CAAC,SAAS,KAAA,EAAE,SAAS,KAAA;IAS/B,QAAQ,CAAC,KAAK,KAAA,EAAE,KAAK,KAAA;IASrB,OAAO;IAEP,IAAI;CAKL"}

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

@@ -0,0 +1,59 @@
+/****************************************************************************
+ 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.
+ ****************************************************************************/
+import { Texture } from '@esotericsoftware/spine-core';
+export class SkeletonTexture extends Texture {
+    constructor(image) {
+        super(image);
+    }
+    name = 'SkeletonTexture';
+    _texture = null;
+    setRealTexture(tex) {
+        this._texture = tex;
+    }
+    getRealTexture() {
+        return this._texture;
+    }
+    setFilters(minFilter, magFilter) {
+        if (cc._renderType === cc.game.RENDER_TYPE_WEBGL) {
+            const gl = cc._renderContext;
+            this.bind();
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, magFilter);
+        }
+    }
+    setWraps(uWrap, vWrap) {
+        if (cc._renderType === cc.game.RENDER_TYPE_WEBGL) {
+            const gl = cc._renderContext;
+            this.bind();
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, uWrap);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, vWrap);
+        }
+    }
+    dispose() { }
+    bind() {
+        if (cc._renderType === cc.game.RENDER_TYPE_WEBGL) {
+            cc.glBindTexture2D(this._texture);
+        }
+    }
+}

package/dist/spine/spine-cocos/CCSkeletonWebGLRenderCmd.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 WebGLRenderCmd: {
+    (renderableObject: any): void;
+    prototype: any;
+};
+//# sourceMappingURL=CCSkeletonWebGLRenderCmd.d.ts.map

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"}