@safe-engine/cocos 2.4.0 → 2.4.1

package/dist/spine/CCSkeletonAnimation.js

@@ -1,311 +0,0 @@
-import * as spine from '@esotericsoftware/spine-core';
-import { Skeleton } from './CCSkeleton';
-import { SkeletonTexture } from './CCSkeletonTexture';
-/****************************************************************************
- Copyright (c) 2011-2012 cocos2d-x.org
- Copyright (c) 2013-2014 Chukong Technologies Inc.
- Copyright (c) 2014 Shengxiang Chen (Nero Chan)
-
- http://www.cocos2d-x.org
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
- ****************************************************************************/
-export const _atlasLoader = {
-    spAtlasFile: null,
-    setAtlasFile: function (spAtlasFile) {
-        this.spAtlasFile = spAtlasFile;
-    },
-    load: function (line) {
-        const texturePath = cc.path.join(cc.path.dirname(this.spAtlasFile), line);
-        const texture = cc.textureCache.addImage(texturePath);
-        const tex = new SkeletonTexture({ width: texture.getPixelsWide(), height: texture.getPixelsHigh() });
-        tex.setRealTexture(texture);
-        return tex;
-    },
-    unload: function () { },
-};
-/**
- * The event type of spine skeleton animation. It contains event types: START(0), END(1), COMPLETE(2), EVENT(3).
- * @constant
- * @type {{START: number, END: number, COMPLETE: number, EVENT: number}}
- */
-const ANIMATION_EVENT_TYPE = {
-    START: 0,
-    INTERRUPT: 1,
-    END: 2,
-    DISPOSE: 3,
-    COMPLETE: 4,
-    EVENT: 5,
-};
-const TrackEntryListeners = function (startListener, endListener, completeListener, eventListener, interruptListener, disposeListener) {
-    this.startListener = startListener || null;
-    this.endListener = endListener || null;
-    this.completeListener = completeListener || null;
-    this.eventListener = eventListener || null;
-    this.interruptListener = interruptListener || null;
-    this.disposeListener = disposeListener || null;
-    this.callback = null;
-    this.callbackTarget = null;
-    this.skeletonNode = null;
-};
-const proto = TrackEntryListeners.prototype;
-proto.start = function (trackEntry) {
-    if (this.startListener) {
-        this.startListener(trackEntry);
-    }
-    if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.START, null, 0);
-    }
-};
-proto.interrupt = function (trackEntry) {
-    if (this.interruptListener) {
-        this.interruptListener(trackEntry);
-    }
-    if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.INTERRUPT, null, 0);
-    }
-};
-proto.end = function (trackEntry) {
-    if (this.endListener) {
-        this.endListener(trackEntry);
-    }
-    if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.END, null, 0);
-    }
-};
-proto.dispose = function (trackEntry) {
-    if (this.disposeListener) {
-        this.disposeListener(trackEntry);
-    }
-    if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.DISPOSE, null, 0);
-    }
-};
-proto.complete = function (trackEntry) {
-    const loopCount = Math.floor(trackEntry.trackTime / trackEntry.animationEnd);
-    if (this.completeListener) {
-        this.completeListener(trackEntry, loopCount);
-    }
-    if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.COMPLETE, null, loopCount);
-    }
-};
-proto.event = function (trackEntry, event) {
-    if (this.eventListener) {
-        this.eventListener(trackEntry, event);
-    }
-    if (this.callback) {
-        this.callback.call(this.callbackTarget, this.skeletonNode, trackEntry, ANIMATION_EVENT_TYPE.EVENT, event, 0);
-    }
-};
-TrackEntryListeners.getListeners = function (entry) {
-    if (!entry.listener) {
-        entry.listener = new TrackEntryListeners();
-    }
-    return entry.listener;
-};
-/**
- * The skeleton animation of spine. It updates animation's state and skeleton's world transform.
- * @class
- * @extends Skeleton
- */
-export class SkeletonAnimation extends Skeleton {
-    _state = null;
-    _ownsAnimationStateData = false;
-    _listener = null;
-    constructor(skeletonDataFile, atlasFile, scale) {
-        super(skeletonDataFile, atlasFile, scale);
-        this._ownsAnimationStateData = true;
-        this.setAnimationStateData(new spine.AnimationStateData(this._skeleton.data));
-    }
-    /**
-     * Sets animation state data to SkeletonAnimation.
-     * @param {spine.AnimationStateData} stateData
-     */
-    setAnimationStateData(stateData) {
-        const state = new spine.AnimationState(stateData);
-        this._listener = new TrackEntryListeners();
-        state.addListener(this._listener);
-        this._state = state;
-    }
-    /**
-     * Mix applies all keyframe values, interpolated for the specified time and mixed with the current values.
-     * @param {String} fromAnimation
-     * @param {String} toAnimation
-     * @param {Number} duration
-     */
-    setMix(fromAnimation, toAnimation, duration) {
-        this._state.data.setMixWith(fromAnimation, toAnimation, duration);
-    }
-    /**
-     * Sets event listener of SkeletonAnimation.
-     * @param {Object} target
-     * @param {Function} callback
-     */
-    setAnimationListener(target, callback) {
-        this._listener.callbackTarget = target;
-        this._listener.callback = callback;
-        this._listener.skeletonNode = this;
-    }
-    /**
-     * Set the current animation. Any queued animations are cleared.
-     * @param {Number} trackIndex
-     * @param {String} name
-     * @param {Boolean} loop
-     * @returns {spine.TrackEntry|null}
-     */
-    setAnimation(trackIndex, name, loop) {
-        const animation = this._skeleton.data.findAnimation(name);
-        if (!animation) {
-            cc.log(`Spine: Animation not found: ${name}`);
-            return null;
-        }
-        return this._state.setAnimationWith(trackIndex, animation, loop);
-    }
-    /**
-     * Adds an animation to be played delay seconds after the current or last queued animation.
-     * @param {Number} trackIndex
-     * @param {String} name
-     * @param {Boolean} loop
-     * @param {Number} [delay=0]
-     * @returns {spine.TrackEntry|null}
-     */
-    addAnimation(trackIndex, name, loop, delay) {
-        delay = delay == null ? 0 : delay;
-        const animation = this._skeleton.data.findAnimation(name);
-        if (!animation) {
-            cc.log(`Spine: Animation not found:${name}`);
-            return null;
-        }
-        return this._state.addAnimationWith(trackIndex, animation, loop, delay);
-    }
-    /**
-     * Find animation with specified name
-     * @param {String} name
-     * @returns {spine.Animation|null}
-     */
-    findAnimation(name) {
-        return this._skeleton.data.findAnimation(name);
-    }
-    /**
-     * Returns track entry by trackIndex.
-     * @param trackIndex
-     * @returns {spine.TrackEntry|null}
-     */
-    getCurrent(trackIndex) {
-        return this._state.getCurrent(trackIndex);
-    }
-    /**
-     * Clears all tracks of animation state.
-     */
-    clearTracks() {
-        this._state.clearTracks();
-    }
-    /**
-     * Clears track of animation state by trackIndex.
-     * @param {Number} trackIndex
-     */
-    clearTrack(trackIndex) {
-        this._state.clearTrack(trackIndex);
-    }
-    /**
-     * Update will be called automatically every frame if "scheduleUpdate" is called when the node is "live".
-     * It updates animation's state and skeleton's world transform.
-     * @param {Number} dt Delta time since last update
-     * @override
-     */
-    update(dt) {
-        super.update(dt);
-        dt *= this._timeScale;
-        this._renderCmd.setDirtyFlag(cc.Node._dirtyFlags.contentDirty);
-        this._state.update(dt);
-        this._state.apply(this._skeleton);
-        this._skeleton.updateWorldTransform(true);
-        this._renderCmd._updateChild();
-    }
-    /**
-     * Set the start event listener.
-     * @param {function} listener
-     */
-    setStartListener(listener) {
-        this._listener.startListener = listener;
-    }
-    /**
-     * Set the interrupt listener
-     * @param {function} listener
-     */
-    setInterruptListener(listener) {
-        this._listener.interruptListener = listener;
-    }
-    /**
-     * Set the end event listener.
-     * @param {function} listener
-     */
-    setEndListener(listener) {
-        this._listener.endListener = listener;
-    }
-    /**
-     * Set the dispose listener
-     * @param {function} listener
-     */
-    setDisposeListener(listener) {
-        this._listener.disposeListener = listener;
-    }
-    setCompleteListener(listener) {
-        this._listener.completeListener = listener;
-    }
-    setEventListener(listener) {
-        this._listener.eventListener = listener;
-    }
-    setTrackStartListener(entry, listener) {
-        TrackEntryListeners.getListeners(entry).startListener = listener;
-    }
-    setTrackInterruptListener(entry, listener) {
-        TrackEntryListeners.getListeners(entry).interruptListener = listener;
-    }
-    setTrackEndListener(entry, listener) {
-        TrackEntryListeners.getListeners(entry).endListener = listener;
-    }
-    setTrackDisposeListener(entry, listener) {
-        TrackEntryListeners.getListeners(entry).disposeListener = listener;
-    }
-    setTrackCompleteListener(entry, listener) {
-        TrackEntryListeners.getListeners(entry).completeListener = listener;
-    }
-    setTrackEventListener(entry, listener) {
-        TrackEntryListeners.getListeners(entry).eventListener = listener;
-    }
-    getState() {
-        return this._state;
-    }
-    /**
-     * Creates a skeleton animation object.
-     * @deprecated since v3.0, please use new SkeletonAnimation(skeletonDataFile, atlasFile, scale) instead.
-     * @param {spine.SkeletonData|String} skeletonDataFile
-     * @param {String|spine.Atlas|spine.SkeletonData} atlasFile atlas filename or atlas data or owns SkeletonData
-     * @param {Number} [scale]
-     * @returns {SkeletonAnimation}
-     */
-    static createWithJsonFile(skeletonDataFile, atlasFile, scale) {
-        return new SkeletonAnimation(skeletonDataFile, atlasFile, scale);
-    }
-    static create(skeletonDataFile, atlasFile, scale) {
-        return new SkeletonAnimation(skeletonDataFile, atlasFile, scale);
-    }
-}

package/dist/spine/CCSkeletonCanvasRenderCmd.d.ts

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,228 +0,0 @@
-import * as spine from '@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.CanvasRenderCmd = function (renderableObject) {
-        this._rootCtor(renderableObject);
-        this._needDraw = true;
-    };
-    const proto = (gworld.CanvasRenderCmd.prototype = Object.create(cc.Node.CanvasRenderCmd.prototype));
-    proto.constructor = gworld.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 spine.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 = spine.Utils.setArraySize([], 8, 0);
-        attachment.computeWorldVertices(slot, vertices, 0, 2);
-        const VERTEX = spine.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 spine.RegionAttachment) {
-                spriteName = attachment.name;
-                sprite = this._createSprite(slot, attachment);
-                slot.currentSprite = sprite;
-                slot.currentSpriteName = spriteName;
-                slotNode.addChild(sprite);
-            }
-            else if (attachment instanceof spine.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 spine.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 spine.MeshAttachment) {
-                // Can not render mesh
-            }
-            else {
-                slotNode.setVisible(false);
-                continue;
-            }
-            slotNode.setVisible(true);
-        }
-    };
-})();
-export const CanvasRenderCmd = gworld.CanvasRenderCmd;

package/dist/spine/CCSkeletonTexture.d.ts

@@ -1,25 +0,0 @@
-/****************************************************************************
- 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 +0,0 @@
-{"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

@@ -1,60 +0,0 @@
-import * as spine from '@esotericsoftware/spine-core';
-/****************************************************************************
- 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 const SkeletonTexture = function (image) {
-    // spine.Texture.call(this, image)
-};
-cc.inherits(SkeletonTexture, spine.Texture);
-cc.extend(SkeletonTexture.prototype, {
-    name: 'gworld.SkeletonTexture',
-    _texture: null,
-    setRealTexture: function (tex) {
-        this._texture = tex;
-    },
-    getRealTexture: function () {
-        return this._texture;
-    },
-    setFilters: function (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: function (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: function () { },
-    bind: function () {
-        if (cc._renderType === cc.game.RENDER_TYPE_WEBGL) {
-            cc.glBindTexture2D(this._texture);
-        }
-    },
-});

package/dist/spine/CCSkeletonWebGLRenderCmd.d.ts

@@ -1,28 +0,0 @@
-/****************************************************************************
- 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 +0,0 @@
-{"version":3,"file":"CCSkeletonWebGLRenderCmd.d.ts","sourceRoot":"","sources":["../../src/spine/CCSkeletonWebGLRenderCmd.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;8EAsB8E;AAE9E,eAAO,MAAM,cAAc;;;CAS1B,CAAA"}