@safe-engine/cocos 1.0.1

package/dist/polyfills.js

@@ -0,0 +1,168 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Touch = exports.BLUE = exports.GREEN = exports.WHITE = exports.BLACK = exports.RED = exports.SpriteType = void 0;
+exports.Vec2 = Vec2;
+exports.Color4B = Color4B;
+exports.Size = Size;
+exports.getWinSize = getWinSize;
+var Intersection_1 = require("./helper/Intersection");
+function updatePoint(p) {
+    var x = p.x, y = p.y;
+    return cc.v2(x, y);
+}
+var _Vec2 = /** @class */ (function () {
+    function _Vec2(x, y) {
+        if (x === void 0) { x = 0; }
+        if (y === void 0) { y = 0; }
+        if (!(this instanceof _Vec2)) {
+            return new _Vec2(x, y);
+        }
+        if (typeof x === 'object') {
+            this.x = x.x;
+            this.y = x.y;
+            return;
+        }
+        this.x = x;
+        this.y = y;
+    }
+    _Vec2.prototype.equals = function (other) {
+        return this.x === other.x && this.y === other.y;
+    };
+    _Vec2.prototype.add = function (value) {
+        return updatePoint(cc.pAdd(cc.p(this.x, this.y), value));
+    };
+    _Vec2.prototype.addSelf = function (value) {
+        var nor = updatePoint(cc.pAdd(cc.p(this.x, this.y), value));
+        this.x = nor.x;
+        this.y = nor.y;
+        return nor;
+    };
+    _Vec2.prototype.sub = function (value) {
+        return updatePoint(cc.pSub(cc.p(this.x, this.y), value));
+    };
+    _Vec2.prototype.mul = function (multiply) {
+        return updatePoint(cc.pMult(cc.p(this.x, this.y), multiply));
+    };
+    _Vec2.prototype.mulSelf = function (multiply) {
+        var nor = updatePoint(cc.pMult(cc.p(this.x, this.y), multiply));
+        this.x = nor.x;
+        this.y = nor.y;
+        return nor;
+    };
+    _Vec2.prototype.mag = function () {
+        return cc.pLength(cc.p(this.x, this.y));
+    };
+    _Vec2.prototype.normalizeSelf = function () {
+        var nor = updatePoint(cc.pNormalize(cc.p(this.x, this.y)));
+        this.x = nor.x;
+        this.y = nor.y;
+        return nor;
+    };
+    _Vec2.prototype.normalize = function () {
+        return updatePoint(cc.pNormalize(cc.p(this.x, this.y)));
+    };
+    _Vec2.prototype.cross = function (other) {
+        return this.x * other.y - this.y * other.x;
+    };
+    _Vec2.prototype.signAngle = function (other) {
+        var angle = this.angle(other);
+        return this.cross(other) < 0 ? -angle : angle;
+    };
+    _Vec2.prototype.lengthSqr = function () {
+        return this.x * this.x + this.y * this.y;
+    };
+    _Vec2.prototype.dot = function (other) {
+        return this.x * other.x + this.y * other.y;
+    };
+    _Vec2.prototype.angle = function (other) {
+        var magSqr1 = this.lengthSqr();
+        var magSqr2 = other.lengthSqr();
+        if (magSqr1 === 0 || magSqr2 === 0) {
+            console.warn('Cant get angle between zero vector');
+            return 0.0;
+        }
+        var dot = this.dot(other);
+        var theta = dot / Math.sqrt(magSqr1 * magSqr2);
+        theta = cc.clampf(theta, -1.0, 1.0);
+        return Math.acos(theta);
+    };
+    _Vec2.prototype.distance = function (other) {
+        return cc.pDistance(this, other);
+    };
+    return _Vec2;
+}());
+function Vec2(x, y) {
+    return new _Vec2(x, y);
+}
+cc.Vec2 = _Vec2;
+Vec2.ZERO = cc.Vec2.ZERO = Object.freeze(Vec2(0, 0));
+var SpriteType;
+(function (SpriteType) {
+    SpriteType[SpriteType["SIMPLE"] = 0] = "SIMPLE";
+    SpriteType[SpriteType["SLICED"] = 1] = "SLICED";
+    SpriteType[SpriteType["TILED"] = 2] = "TILED";
+    SpriteType[SpriteType["FILLED"] = 3] = "FILLED";
+    SpriteType[SpriteType["MESH"] = 4] = "MESH";
+})(SpriteType || (exports.SpriteType = SpriteType = {}));
+exports.RED = Color4B(255, 0, 0, 255);
+exports.BLACK = Color4B(0, 0, 0, 255);
+exports.WHITE = Color4B(255, 255, 255, 255);
+exports.GREEN = Color4B(0, 255, 0, 255);
+exports.BLUE = Color4B(0, 0, 255, 255);
+cc.Color.DEBUG_FILL_COLOR = cc.color(255, 255, 0, 150);
+cc.Color.DEBUG_BORDER_COLOR = cc.color(255, 0, 0, 255);
+cc.Color.prototype.fromHEX = cc.hexToColor;
+cc.Intersection = {
+    polygonPolygon: Intersection_1.polygonPolygon,
+    circleCircle: Intersection_1.circleCircle,
+    polygonCircle: Intersection_1.polygonCircle,
+    pointInPolygon: Intersection_1.pointInPolygon,
+};
+function Color4B(r, g, b, a) {
+    return cc.color(r, g, b, a);
+}
+var _Size = /** @class */ (function () {
+    function _Size(width, height) {
+        if (width === void 0) { width = 0; }
+        if (height === void 0) { height = 0; }
+        if (!(this instanceof _Size)) {
+            return new _Size(width, height);
+        }
+        if (height === undefined) {
+            this.width = width.width;
+            this.height = width.height;
+        }
+        this.width = width;
+        this.height = height;
+    }
+    return _Size;
+}());
+function Size(x, y) {
+    return new _Size(x, y);
+}
+var Touch = /** @class */ (function (_super) {
+    __extends(Touch, _super);
+    function Touch() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return Touch;
+}(cc.Touch));
+exports.Touch = Touch;
+function getWinSize() {
+    return cc.director.getWinSize();
+}

package/dist/spine/CCSkeleton.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"CCSkeleton.d.ts","sourceRoot":"","sources":["../../src/spine/CCSkeleton.ts"],"names":[],"mappings":"AAiaA,eAAO,MAAM,QAAQ,KAAkB,CAAA"}

package/dist/spine/CCSkeleton.js

@@ -0,0 +1,380 @@
+"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.Skeleton = void 0;
+var spine = __importStar(require("@esotericsoftware/spine-core"));
+var spine_core_1 = require("@esotericsoftware/spine-core");
+var CCSkeletonAnimation_1 = require("./CCSkeletonAnimation");
+var CCSkeletonWebGLRenderCmd_1 = require("./CCSkeletonWebGLRenderCmd");
+/****************************************************************************
+ 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.
+ ****************************************************************************/
+/**
+ * The main namespace of Spine, all classes, functions, properties and constants of Spine are defined in this namespace
+ * @namespace
+ * @name gworld
+ */
+var gworld = gworld || {};
+/**
+ * <p>
+ *     The skeleton of Spine.                                                                          <br/>
+ *     Skeleton has a reference to a SkeletonData and stores the state for skeleton instance,
+ *     which consists of the current pose's bone SRT, slot colors, and which slot attachments are visible.           <br/>
+ *     Multiple skeletons can use the same SkeletonData (which includes all animations, skins, and attachments).     <br/>
+ * </p>
+ * @class
+ * @extends cc.Node
+ */
+gworld.Skeleton = cc.Node.extend(
+/** @lends gworld.Skeleton# */ {
+    _skeleton: null,
+    _rootBone: null,
+    _timeScale: 1,
+    _debugSlots: false,
+    _debugBones: false,
+    _premultipliedAlpha: false,
+    _ownsSkeletonData: null,
+    _atlas: null,
+    /**
+     * The constructor of gworld.Skeleton. override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function.
+     */
+    ctor: function (skeletonDataFile, atlasFile, scale) {
+        cc.Node.prototype.ctor.call(this);
+        if (arguments.length === 0)
+            this.init();
+        else
+            this.initWithArgs(skeletonDataFile, atlasFile, scale);
+    },
+    _createRenderCmd: function () {
+        if (cc._renderType === cc.game.RENDER_TYPE_CANVAS)
+            return new gworld.Skeleton.CanvasRenderCmd(this);
+        else
+            return new CCSkeletonWebGLRenderCmd_1.WebGLRenderCmd(this);
+    },
+    /**
+     * Initializes a gworld.Skeleton. please do not call this function by yourself, you should pass the parameters to constructor to initialize it.
+     */
+    init: function () {
+        cc.Node.prototype.init.call(this);
+        this._premultipliedAlpha = cc._renderType === cc.game.RENDER_TYPE_WEBGL && cc.OPTIMIZE_BLEND_FUNC_FOR_PREMULTIPLIED_ALPHA;
+    },
+    onEnter: function () {
+        cc.Node.prototype.onEnter.call(this);
+        this.scheduleUpdate();
+    },
+    onExit: function () {
+        this.unscheduleUpdate();
+        cc.Node.prototype.onExit.call(this);
+    },
+    /**
+     * Sets whether open debug slots.
+     * @param {boolean} enable true to open, false to close.
+     */
+    setDebugSolots: function (enable) {
+        this._debugSlots = enable;
+    },
+    /**
+     * Sets whether open debug bones.
+     * @param {boolean} enable
+     */
+    setDebugBones: function (enable) {
+        this._debugBones = enable;
+    },
+    /**
+     * Sets whether open debug slots.
+     * @param {boolean} enabled true to open, false to close.
+     */
+    setDebugSlotsEnabled: function (enabled) {
+        this._debugSlots = enabled;
+    },
+    /**
+     * Gets whether open debug slots.
+     * @returns {boolean} true to open, false to close.
+     */
+    getDebugSlotsEnabled: function () {
+        return this._debugSlots;
+    },
+    /**
+     * Sets whether open debug bones.
+     * @param {boolean} enabled
+     */
+    setDebugBonesEnabled: function (enabled) {
+        this._debugBones = enabled;
+    },
+    /**
+     * Gets whether open debug bones.
+     * @returns {boolean} true to open, false to close.
+     */
+    getDebugBonesEnabled: function () {
+        return this._debugBones;
+    },
+    /**
+     * Sets the time scale of gworld.Skeleton.
+     * @param {Number} scale
+     */
+    setTimeScale: function (scale) {
+        this._timeScale = scale;
+    },
+    getTimeScale: function () {
+        return this._timeScale;
+    },
+    /**
+     * Initializes gworld.Skeleton with Data.
+     * @param {gworld.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.
+     */
+    initWithArgs: function (skeletonDataFile, atlasFile, scale) {
+        var argSkeletonFile = skeletonDataFile, argAtlasFile = atlasFile, skeletonData, atlas, ownsSkeletonData;
+        if (cc.isString(argSkeletonFile)) {
+            if (cc.isString(argAtlasFile)) {
+                var data = cc.loader.getRes(argAtlasFile);
+                CCSkeletonAnimation_1._atlasLoader.setAtlasFile(argAtlasFile);
+                atlas = new spine_core_1.TextureAtlas(data);
+                for (var _i = 0, _a = atlas.pages; _i < _a.length; _i++) {
+                    var page = _a[_i];
+                    var texture = CCSkeletonAnimation_1._atlasLoader.load(page.name);
+                    page.setTexture(texture);
+                }
+            }
+            scale = scale || 1 / cc.director.getContentScaleFactor();
+            var attachmentLoader = new spine_core_1.AtlasAttachmentLoader(atlas);
+            var skeletonJsonReader = new spine_core_1.SkeletonJson(attachmentLoader);
+            skeletonJsonReader.scale = scale;
+            var skeletonJson = cc.loader.getRes(argSkeletonFile);
+            skeletonData = skeletonJsonReader.readSkeletonData(skeletonJson);
+            atlas.dispose(skeletonJsonReader);
+            ownsSkeletonData = true;
+        }
+        else {
+            skeletonData = skeletonDataFile;
+            ownsSkeletonData = atlasFile;
+        }
+        this.setSkeletonData(skeletonData, ownsSkeletonData);
+        this.init();
+    },
+    /**
+     * Returns the bounding box of gworld.Skeleton.
+     * @returns {cc.Rect}
+     */
+    getBoundingBox: function () {
+        var minX = cc.FLT_MAX, minY = cc.FLT_MAX, maxX = cc.FLT_MIN, maxY = cc.FLT_MIN;
+        var scaleX = this.getScaleX(), scaleY = this.getScaleY(), vertices, slots = this._skeleton.slots, VERTEX = spine.RegionAttachment;
+        for (var i = 0, slotCount = slots.length; i < slotCount; ++i) {
+            var slot = slots[i];
+            var attachment = slot.attachment;
+            if (!attachment || !(attachment instanceof spine.RegionAttachment))
+                continue;
+            vertices = spine.Utils.setArraySize([], 8, 0);
+            attachment.computeWorldVertices(slot, vertices, 0, 2);
+            minX = Math.min(minX, vertices[VERTEX.X1] * scaleX, vertices[VERTEX.X4] * scaleX, vertices[VERTEX.X2] * scaleX, vertices[VERTEX.X3] * scaleX);
+            minY = Math.min(minY, vertices[VERTEX.Y1] * scaleY, vertices[VERTEX.Y4] * scaleY, vertices[VERTEX.Y2] * scaleY, vertices[VERTEX.Y3] * scaleY);
+            maxX = Math.max(maxX, vertices[VERTEX.X1] * scaleX, vertices[VERTEX.X4] * scaleX, vertices[VERTEX.X2] * scaleX, vertices[VERTEX.X3] * scaleX);
+            maxY = Math.max(maxY, vertices[VERTEX.Y1] * scaleY, vertices[VERTEX.Y4] * scaleY, vertices[VERTEX.Y2] * scaleY, vertices[VERTEX.Y3] * scaleY);
+        }
+        var position = this.getPosition();
+        return cc.rect(position.x + minX, position.y + minY, maxX - minX, maxY - minY);
+    },
+    /**
+     * Computes the world SRT from the local SRT for each bone.
+     */
+    updateWorldTransform: function () {
+        this._skeleton.updateWorldTransform(true);
+    },
+    /**
+     * Sets the bones and slots to the setup pose.
+     */
+    setToSetupPose: function () {
+        this._skeleton.setToSetupPose();
+    },
+    /**
+     * Sets the bones to the setup pose, using the values from the `BoneData` list in the `SkeletonData`.
+     */
+    setBonesToSetupPose: function () {
+        this._skeleton.setBonesToSetupPose();
+    },
+    /**
+     * Sets the slots to the setup pose, using the values from the `SlotData` list in the `SkeletonData`.
+     */
+    setSlotsToSetupPose: function () {
+        this._skeleton.setSlotsToSetupPose();
+    },
+    /**
+     * Finds a bone by name. This does a string comparison for every bone.
+     * @param {String} boneName
+     * @returns {gworld.spine.Bone}
+     */
+    findBone: function (boneName) {
+        return this._skeleton.findBone(boneName);
+    },
+    /**
+     * Finds a slot by name. This does a string comparison for every slot.
+     * @param {String} slotName
+     * @returns {gworld.spine.Slot}
+     */
+    findSlot: function (slotName) {
+        return this._skeleton.findSlot(slotName);
+    },
+    /**
+     * Finds a skin by name and makes it the active skin. This does a string comparison for every skin. Note that setting the skin does not change which attachments are visible.
+     * @param {string} skinName
+     * @returns {gworld.spine.Skin}
+     */
+    setSkin: function (skinName) {
+        return this._skeleton.setSkinByName(skinName);
+    },
+    /**
+     * Returns the attachment for the slot and attachment name. The skeleton looks first in its skin, then in the skeleton data’s default skin.
+     * @param {String} slotName
+     * @param {String} attachmentName
+     * @returns {gworld.spine.Attachment}
+     */
+    getAttachment: function (slotName, attachmentName) {
+        return this._skeleton.getAttachmentByName(slotName, attachmentName);
+    },
+    /**
+     * Sets the attachment for the slot and attachment name. The skeleton looks first in its skin, then in the skeleton data’s default skin.
+     * @param {String} slotName
+     * @param {String} attachmentName
+     */
+    setAttachment: function (slotName, attachmentName) {
+        this._skeleton.setAttachment(slotName, attachmentName);
+    },
+    /**
+     * Sets the premultiplied alpha value to gworld.Skeleton.
+     * @param {Number} alpha
+     */
+    setPremultipliedAlpha: function (premultiplied) {
+        this._premultipliedAlpha = premultiplied;
+    },
+    /**
+     * Returns whether to enable premultiplied alpha.
+     * @returns {boolean}
+     */
+    isPremultipliedAlpha: function () {
+        return this._premultipliedAlpha;
+    },
+    /**
+     * Sets skeleton data to gworld.Skeleton.
+     * @param {gworld.spine.SkeletonData} skeletonData
+     * @param {gworld.spine.SkeletonData} ownsSkeletonData
+     */
+    setSkeletonData: function (skeletonData, ownsSkeletonData) {
+        if (skeletonData.width != null && skeletonData.height != null)
+            this.setContentSize(skeletonData.width / cc.director.getContentScaleFactor(), skeletonData.height / cc.director.getContentScaleFactor());
+        this._skeleton = new spine.Skeleton(skeletonData);
+        this._skeleton.updateWorldTransform(true);
+        this._rootBone = this._skeleton.getRootBone();
+        this._ownsSkeletonData = ownsSkeletonData;
+        this._renderCmd._createChildFormSkeletonData();
+    },
+    /**
+     * Return the renderer of attachment.
+     * @param {gworld.spine.RegionAttachment|gworld.spine.BoundingBoxAttachment} regionAttachment
+     * @returns {gworld.spine.TextureAtlasRegion}
+     */
+    getTextureAtlas: function (regionAttachment) {
+        return regionAttachment.region;
+    },
+    /**
+     * Returns the blendFunc of gworld.Skeleton.
+     * @returns {cc.BlendFunc}
+     */
+    getBlendFunc: function () {
+        var slot = this._skeleton.drawOrder[0];
+        if (slot) {
+            var blend = this._renderCmd._getBlendFunc(slot.data.blendMode, this._premultipliedAlpha);
+            return blend;
+        }
+        else {
+            return {};
+        }
+    },
+    /**
+     * Sets the blendFunc of gworld.Skeleton, it won't have any effect for skeleton, skeleton is using slot's data to determine the blend function.
+     * @param {cc.BlendFunc|Number} src
+     * @param {Number} [dst]
+     */
+    setBlendFunc: function (src, dst) {
+        return;
+    },
+    /**
+     * Update will be called automatically every frame if "scheduleUpdate" is called when the node is "live".
+     * @param {Number} dt Delta time since last update
+     */
+    update: function (dt) {
+        this._skeleton.update(dt);
+    },
+});
+cc.defineGetterSetter(gworld.Skeleton.prototype, 'opacityModifyRGB', gworld.Skeleton.prototype.isOpacityModifyRGB);
+// For renderer webgl to identify skeleton's default texture and blend function
+cc.defineGetterSetter(gworld.Skeleton.prototype, '_blendFunc', gworld.Skeleton.prototype.getBlendFunc);
+cc.defineGetterSetter(gworld.Skeleton.prototype, '_texture', function () {
+    return this._renderCmd._currTexture;
+});
+/**
+ * Creates a skeleton object.
+ * @deprecated since v3.0, please use new gworld.Skeleton(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}
+ */
+gworld.Skeleton.create = function (skeletonDataFile, atlasFile /* or atlas*/, scale) {
+    return new gworld.Skeleton(skeletonDataFile, atlasFile, scale);
+};
+exports.Skeleton = gworld.Skeleton;

package/dist/spine/CCSkeletonAnimation.d.ts

@@ -0,0 +1,16 @@
+export declare const _atlasLoader: {
+    spAtlasFile: any;
+    setAtlasFile: (spAtlasFile: any) => void;
+    load: (line: any) => any;
+    unload: (obj: any) => void;
+};
+/**
+ * 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);
+ */
+export declare const SkeletonAnimation: any;
+//# sourceMappingURL=CCSkeletonAnimation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CCSkeletonAnimation.d.ts","sourceRoot":"","sources":["../../src/spine/CCSkeletonAnimation.ts"],"names":[],"mappings":"AA+BA,eAAO,MAAM,YAAY;;;;;CAaxB,CAAA;AA2FD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,KAuM5B,CAAA"}