@safe-engine/cocos 2.2.8 → 2.3.4

package/dist/render/RenderSystem.js

@@ -2,7 +2,6 @@ import { EventTypes } from 'entityx-ts';
 import { NodeComp } from '../core/NodeComp';
 import { BLUE, RED } from '../polyfills';
 import { GraphicsRender, MaskRender, MotionStreakComp, NodeRender, ParticleComp, SpriteRender, TiledMap } from './RenderComponent';
-import { TiledSprite } from './TiledSprite';
 export var SpriteTypes;
 (function (SpriteTypes) {
     SpriteTypes[SpriteTypes["SIMPLE"] = 0] = "SIMPLE";
@@ -12,6 +11,39 @@ export var SpriteTypes;
     SpriteTypes[SpriteTypes["MESH"] = 4] = "MESH";
     SpriteTypes[SpriteTypes["ANIMATION"] = 5] = "ANIMATION";
 })(SpriteTypes || (SpriteTypes = {}));
+function createTiledSprite(src, totalW, totalH) {
+    // tạo sprite từ input
+    const tileSprite = new cc.Sprite(src);
+    // lấy kích thước gốc của texture
+    const frame = tileSprite.getSpriteFrame();
+    const tileW = frame ? frame.getRect().width : tileSprite.getContentSize().width;
+    const tileH = frame ? frame.getRect().height : tileSprite.getContentSize().height;
+    // tạo renderTexture với kích thước cần phủ
+    const rt = new cc.RenderTexture(totalW, totalH);
+    rt.beginWithClear(0, 0, 0, 0);
+    const drawSprite = new cc.Sprite(tileSprite.getTexture());
+    // if (frame) {
+    //   drawSprite.setSpriteFrame(frame)
+    // }
+    drawSprite.setAnchorPoint(0, 0);
+    // số tile theo trục x,y
+    const cols = Math.ceil(totalW / tileW);
+    const rows = Math.ceil(totalH / tileH);
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+            const s = new cc.Sprite(frame);
+            s.setAnchorPoint(0, 0);
+            s.setPosition(c * tileW, r * tileH);
+            s.visit(rt);
+        }
+    }
+    rt.end();
+    const finalSprite = rt.sprite;
+    finalSprite.setFlippedY(true); // RenderTexture bị lật
+    finalSprite.setAnchorPoint(0, 0);
+    finalSprite.setContentSize(cc.size(totalW, totalH));
+    return new cc.Sprite(finalSprite.texture);
+}
 export class RenderSystem {
     configure(event_manager) {
         event_manager.subscribe(EventTypes.ComponentAdded, NodeRender, this.onAddNodeRender);
@@ -35,7 +67,7 @@ export class RenderSystem {
         // console.log('frame', spriteFrame, frame)
         let node;
         if (tiledSize) {
-            node = new TiledSprite({ texture: spriteFrame, width: tiledSize.width, height: tiledSize.height });
+            node = createTiledSprite(spriteFrame, tiledSize.width, tiledSize.height);
         }
         else if (capInsets) {
             const rect = cc.rect(...capInsets);

package/dist/richtext/RichTextComp.js

@@ -22,7 +22,7 @@ export class RichTextComp extends ComponentX {
                     // console.log('richText', richText, (ccui as any).RichElementCustomNode)
                     const label = new ccui.Text(text, fontName, fontSize);
                     label.enableOutline(cc.hexToColor(style.outline.color), style.outline.width || 3);
-                    const customElem = new ccui.RichElementCustomNode.create(1, cc.color(255, 0, 0), 255, label);
+                    const customElem = ccui.RichElementCustomNode.create(1, cc.color(255, 0, 0), 255, label);
                     this.node.instance.pushBackElement(customElem);
                 }
                 else {

package/dist/spine/SpineSkeleton.d.ts

@@ -1,5 +1,5 @@
 import { BaseComponentProps, ComponentX } from '..';
-import { PixiSpineSprite } from './PixiSpineSprite';
+import { SkeletonAnimation } from './spine-cocos/CCSkeletonAnimation';
 export interface SpineData {
     atlas: string;
     skeleton: string;
@@ -11,9 +11,11 @@ interface SpineSkeletonProps {
     animation?: string;
     timeScale?: number;
     loop?: boolean;
+    onAnimationComplete?: any;
 }
-export declare class SpineSkeleton extends ComponentX<SpineSkeletonProps & BaseComponentProps<SpineSkeleton>, cc.Node> {
-    spine: PixiSpineSprite;
+export declare class SpineSkeleton extends ComponentX<SpineSkeletonProps & BaseComponentProps<SpineSkeleton>, SkeletonAnimation> {
+    set scaleX(flip: number);
+    getAnimationName(): string;
     setAnimation(name: string, loop?: boolean): void;
 }
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"SpineSkeleton.d.ts","sourceRoot":"","sources":["../../src/spine/SpineSkeleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAU,MAAM,IAAI,CAAA;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEnD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,kBAAkB;IAC1B,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AACD,qBAAa,aAAc,SAAQ,UAAU,CAAC,kBAAkB,GAAG,kBAAkB,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC;IAC5G,KAAK,EAAE,eAAe,CAAA;IAEtB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,UAAO;CAYvC"}
+{"version":3,"file":"SpineSkeleton.d.ts","sourceRoot":"","sources":["../../src/spine/SpineSkeleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAU,MAAM,IAAI,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAErE,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,kBAAkB;IAC1B,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,mBAAmB,CAAC,MAAA;CACrB;AACD,qBAAa,aAAc,SAAQ,UAAU,CAAC,kBAAkB,GAAG,kBAAkB,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IACtH,IAAI,MAAM,CAAC,IAAI,EAAE,MAAM,EAGtB;IACD,gBAAgB;IAIhB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,UAAQ;CAYxC"}

package/dist/spine/SpineSkeleton.js

@@ -1,10 +1,17 @@
 import { ComponentX, render } from '..';
 export class SpineSkeleton extends ComponentX {
-    spine;
-    setAnimation(name, loop = true) {
-        const skel = this.spine;
-        if (skel._armatureDisplay.state.setAnimation) {
-            skel._armatureDisplay.state.setAnimation(0, name, loop);
+    set scaleX(flip) {
+        const skel = this.node.instance;
+        skel._skeleton.scaleX = flip;
+    }
+    getAnimationName() {
+        const skel = this.node.instance;
+        return skel.getState().getCurrent(0).animation.name;
+    }
+    setAnimation(name, loop = false) {
+        const skel = this.node.instance;
+        if (skel.setAnimation) {
+            skel.setAnimation(0, name, loop);
         }
     }
 }

package/dist/spine/SpineSystem.d.ts

@@ -1,7 +1,6 @@
-import { EntityManager, EventManager, System } from 'entityx-ts';
+import { EventManager, System } from 'entityx-ts';
 export declare class SpineSystem implements System {
     configure(event_manager: EventManager): void;
     private onAddSpineSkeleton;
-    update(entities: EntityManager): void;
 }
 //# sourceMappingURL=SpineSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SpineSystem.d.ts","sourceRoot":"","sources":["../../src/spine/SpineSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAoC,MAAM,EAAE,MAAM,YAAY,CAAA;AAMlG,qBAAa,WAAY,YAAW,MAAM;IACxC,SAAS,CAAC,aAAa,EAAE,YAAY;IAGrC,OAAO,CAAC,kBAAkB,CAiBzB;IACD,MAAM,CAAC,QAAQ,EAAE,aAAa;CAS/B"}
+{"version":3,"file":"SpineSystem.d.ts","sourceRoot":"","sources":["../../src/spine/SpineSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAoC,MAAM,EAAE,MAAM,YAAY,CAAA;AAMnF,qBAAa,WAAY,YAAW,MAAM;IACxC,SAAS,CAAC,aAAa,EAAE,YAAY;IAGrC,OAAO,CAAC,kBAAkB,CAuBzB;CAUF"}

package/dist/spine/SpineSystem.js

@@ -1,36 +1,34 @@
 import { EventTypes } from 'entityx-ts';
 import { NodeComp } from '../core/NodeComp';
-import { PixiSpineSprite } from './PixiSpineSprite';
 import { SpineSkeleton } from './SpineSkeleton';
+import { SkeletonAnimation } from './spine-cocos/CCSkeletonAnimation';
 export class SpineSystem {
     configure(event_manager) {
         event_manager.subscribe(EventTypes.ComponentAdded, SpineSkeleton, this.onAddSpineSkeleton);
     }
     onAddSpineSkeleton = async ({ entity, component: spineComp }) => {
-        const { data, skin, animation, loop = true, timeScale = 1 } = spineComp.props;
-        const { atlas, skeleton, texture } = data;
+        const { data, skin, animation, loop = true, timeScale = 1, onAnimationComplete } = spineComp.props;
+        const { atlas: argAtlasFile, skeleton } = data;
         // console.log('spineComp', data)
-        const spine = new PixiSpineSprite({
-            skeleton,
-            atlas,
-            texture,
-            animationName: animation,
-            loop,
-            skin,
-            timeScale,
-        });
-        const node = new cc.Node();
-        node.addChild(spine);
-        spineComp.spine = spine;
+        let node;
+        if (skeleton.endsWith('.json')) {
+            node = SkeletonAnimation.createWithJsonFile(skeleton, argAtlasFile, timeScale);
+        }
+        else {
+            node = SkeletonAnimation.createWithBinaryFile(skeleton, argAtlasFile, timeScale);
+        }
+        if (skin) {
+            node.setSkin(skin);
+        }
+        if (animation) {
+            node.setAnimation(0, animation, loop);
+        }
         spineComp.node = entity.assign(new NodeComp(node, entity));
+        if (onAnimationComplete) {
+            node.setCompleteListener((track, loopCount) => {
+                // console.log(track, loopCount)
+                onAnimationComplete(track, loopCount);
+            });
+        }
     };
-    update(entities) {
-        const animations = entities.entities_with_components(SpineSkeleton);
-        animations.forEach((ett) => {
-            const spine = ett.getComponent(SpineSkeleton);
-            if (spine.node && spine.node.active) {
-                spine.spine.updateTexture();
-            }
-        });
-    }
 }

package/dist/spine/index.d.ts

@@ -1,4 +1,3 @@
-export * from './PixiSpineSprite';
 export * from './SpineSkeleton';
 export declare function setupSpine(): void;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spine/index.ts"],"names":[],"mappings":"AAGA,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAE/B,wBAAgB,UAAU,SAEzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spine/index.ts"],"names":[],"mappings":"AAGA,cAAc,iBAAiB,CAAA;AAE/B,wBAAgB,UAAU,SAEzB"}

package/dist/spine/index.js

@@ -1,7 +1,19 @@
 import { GameWorld } from '..';
 import { SpineSystem } from './SpineSystem';
-export * from './PixiSpineSprite';
 export * from './SpineSkeleton';
 export function setupSpine() {
-    GameWorld.Instance.addSystemAndUpdate(SpineSystem);
+    GameWorld.Instance.systems.addThenConfigure(SpineSystem);
 }
+cc.loader.register(['skel'], {
+    TYPE: { skel: 'binary' },
+    load: function (realUrl, url, res, callback) {
+        cc.loader.loadBinary(url, function (err, data) {
+            // console.log('loadBinary Skeleton', realUrl, url, res, data, callback)
+            if (err) {
+                callback(err);
+                return;
+            }
+            callback(null, data);
+        });
+    },
+});

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

@@ -0,0 +1,86 @@
+import { AnimationState, Bone, Skeleton } from '@esotericsoftware/spine-core';
+/****************************************************************************
+ 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
+ */
+/**
+ * <p>
+ *     The skeleton of                                                                           <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
+ */
+export declare class CCSkeleton extends cc.Node {
+    _skeleton: Skeleton;
+    _rootBone: Bone;
+    _timeScale: number;
+    _debugSlots: boolean;
+    _debugBones: boolean;
+    _premultipliedAlpha: boolean;
+    _ownsSkeletonData: any;
+    _renderCmd: any;
+    _state: AnimationState;
+    _ownsAnimationStateData: boolean;
+    _listener: any;
+    constructor(skeletonDataFile?: any, atlasFile?: any, scale?: any);
+    _createRenderCmd(): any;
+    init(): boolean;
+    onEnter(): void;
+    onExit(): void;
+    setDebugSolots(enable: boolean): void;
+    setDebugBones(enable: boolean): void;
+    setDebugSlotsEnabled(enabled: boolean): void;
+    getDebugSlotsEnabled(): boolean;
+    setDebugBonesEnabled(enabled: boolean): void;
+    getDebugBonesEnabled(): boolean;
+    setTimeScale(scale: number): void;
+    getTimeScale(): number;
+    initWithArgs(skeletonDataFile: any, atlasFile: any, scale: any): void;
+    getBoundingBox(): cc.Rect;
+    updateWorldTransform(): void;
+    setToSetupPose(): void;
+    setBonesToSetupPose(): void;
+    setSlotsToSetupPose(): void;
+    findBone(boneName: string): Bone;
+    findSlot(slotName: string): import("@esotericsoftware/spine-core").Slot;
+    setSkin(skinName: string): void;
+    getAttachment(slotName: string, attachmentName: string): import("@esotericsoftware/spine-core").Attachment;
+    setAttachment(slotName: string, attachmentName: string): void;
+    setPremultipliedAlpha(premultiplied: boolean): void;
+    isPremultipliedAlpha(): boolean;
+    setSkeletonData(skeletonData: any, ownsSkeletonData: any): void;
+    getTextureAtlas(regionAttachment: any): any;
+    getBlendFunc(): any;
+    setBlendFunc(): void;
+    update(dt: any): void;
+}
+//# sourceMappingURL=CCSkeleton.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CCSkeleton.d.ts","sourceRoot":"","sources":["../../../src/spine/spine-cocos/CCSkeleton.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAEd,IAAI,EAGJ,QAAQ,EAIT,MAAM,8BAA8B,CAAA;AAKrC;;;;;;;;;;;;;;;;;;;;;;;;8EAwB8E;AAE9E;;;;GAIG;AACH;;;;;;;;;GASG;AACH,qBAAa,UAAW,SAAQ,EAAE,CAAC,IAAI;IACrC,SAAS,EAAE,QAAQ,CAAO;IAC1B,SAAS,EAAE,IAAI,CAAO;IACtB,UAAU,SAAI;IACd,WAAW,UAAQ;IACnB,WAAW,UAAQ;IACnB,mBAAmB,UAAQ;IAC3B,iBAAiB,EAAE,GAAG,CAAO;IAC7B,UAAU,EAAE,GAAG,CAAA;IACf,MAAM,EAAE,cAAc,CAAA;IACtB,uBAAuB,UAAQ;IAC/B,SAAS,EAAE,GAAG,CAAA;gBAEF,gBAAgB,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,GAAG;IAWhE,gBAAgB;IAKhB,IAAI,IAAI,OAAO;IAMf,OAAO;IAKP,MAAM;IAKN,cAAc,CAAC,MAAM,EAAE,OAAO;IAI9B,aAAa,CAAC,MAAM,EAAE,OAAO;IAI7B,oBAAoB,CAAC,OAAO,EAAE,OAAO;IAIrC,oBAAoB;IAIpB,oBAAoB,CAAC,OAAO,EAAE,OAAO;IAIrC,oBAAoB;IAIpB,YAAY,CAAC,KAAK,EAAE,MAAM;IAI1B,YAAY;IAIZ,YAAY,CAAC,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG;IAiC9D,cAAc;IAkDd,oBAAoB;IAIpB,cAAc;IAId,mBAAmB;IAInB,mBAAmB;IAInB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAIzB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAIzB,OAAO,CAAC,QAAQ,EAAE,MAAM;IAIxB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IAItD,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IAItD,qBAAqB,CAAC,aAAa,EAAE,OAAO;IAI5C,oBAAoB;IAIpB,eAAe,CAAC,YAAY,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG;IAiBxD,eAAe,CAAC,gBAAgB,EAAE,GAAG;IAIrC,YAAY;IAaZ,YAAY;IAIZ,MAAM,CAAC,EAAE,EAAE,GAAG;CAGf"}

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

@@ -1,5 +1,4 @@
-import * as spine from '@esotericsoftware/spine-core';
-import { AtlasAttachmentLoader, SkeletonJson, TextureAtlas } from '@esotericsoftware/spine-core';
+import { AtlasAttachmentLoader, Physics, RegionAttachment, Skeleton, SkeletonJson, TextureAtlas, Utils, } from '@esotericsoftware/spine-core';
 import { _atlasLoader } from './CCSkeletonAnimation';
 import { CanvasRenderCmd } from './CCSkeletonCanvasRenderCmd';
 import { WebGLRenderCmd } from './CCSkeletonWebGLRenderCmd';
@@ -31,11 +30,11 @@ import { WebGLRenderCmd } from './CCSkeletonWebGLRenderCmd';
 /**
  * The main namespace of Spine, all classes, functions, properties and constants of Spine are defined in this namespace
  * @namespace
- * @name
+ * @name gworld
  */
 /**
  * <p>
- *     The skeleton of Spine.                                                                          <br/>
+ *     The skeleton of                                                                           <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/>
@@ -43,20 +42,28 @@ import { WebGLRenderCmd } from './CCSkeletonWebGLRenderCmd';
  * @class
  * @extends cc.Node
  */
-export class Skeleton extends cc.Node {
+export class CCSkeleton extends cc.Node {
     _skeleton = null;
     _rootBone = null;
     _timeScale = 1;
     _debugSlots = false;
     _debugBones = false;
-    _premultipliedAlpha;
+    _premultipliedAlpha = false;
     _ownsSkeletonData = null;
-    _atlas = null;
+    _renderCmd;
+    _state;
+    _ownsAnimationStateData = false;
+    _listener;
     constructor(skeletonDataFile, atlasFile, scale) {
         super();
-        super.init();
-        this._premultipliedAlpha = cc._renderType === cc.game.RENDER_TYPE_WEBGL && cc.OPTIMIZE_BLEND_FUNC_FOR_PREMULTIPLIED_ALPHA;
-        this.initWithArgs(skeletonDataFile, atlasFile, scale);
+        super.ctor();
+        this._renderCmd = this._createRenderCmd();
+        if (arguments.length === 0) {
+            this.init();
+        }
+        else {
+            this.initWithArgs(skeletonDataFile, atlasFile, scale);
+        }
     }
     _createRenderCmd() {
         if (cc._renderType === cc.game.RENDER_TYPE_CANVAS)
@@ -64,6 +71,11 @@ export class Skeleton extends cc.Node {
         else
             return new WebGLRenderCmd(this);
     }
+    init() {
+        super.init();
+        this._premultipliedAlpha = !!(cc._renderType === cc.game.RENDER_TYPE_WEBGL && cc.OPTIMIZE_BLEND_FUNC_FOR_PREMULTIPLIED_ALPHA);
+        return true;
+    }
     onEnter() {
         super.onEnter();
         this.scheduleUpdate();
@@ -72,66 +84,33 @@ export class Skeleton extends cc.Node {
         this.unscheduleUpdate();
         super.onExit();
     }
-    /**
-     * Sets whether open debug slots.
-     * @param {boolean} enable true to open, false to close.
-     */
     setDebugSolots(enable) {
         this._debugSlots = enable;
     }
-    /**
-     * Sets whether open debug bones.
-     * @param {boolean} enable
-     */
     setDebugBones(enable) {
         this._debugBones = enable;
     }
-    /**
-     * Sets whether open debug slots.
-     * @param {boolean} enabled true to open, false to close.
-     */
     setDebugSlotsEnabled(enabled) {
         this._debugSlots = enabled;
     }
-    /**
-     * Gets whether open debug slots.
-     * @returns {boolean} true to open, false to close.
-     */
     getDebugSlotsEnabled() {
         return this._debugSlots;
     }
-    /**
-     * Sets whether open debug bones.
-     * @param {boolean} enabled
-     */
     setDebugBonesEnabled(enabled) {
         this._debugBones = enabled;
     }
-    /**
-     * Gets whether open debug bones.
-     * @returns {boolean} true to open, false to close.
-     */
     getDebugBonesEnabled() {
         return this._debugBones;
     }
-    /**
-     * Sets the time scale of Skeleton.
-     * @param {Number} scale
-     */
     setTimeScale(scale) {
         this._timeScale = scale;
     }
     getTimeScale() {
         return this._timeScale;
     }
-    /**
-     * Initializes Skeleton with Data.
-     * @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.
-     */
     initWithArgs(skeletonDataFile, atlasFile, scale) {
-        const argSkeletonFile = skeletonDataFile, argAtlasFile = atlasFile;
+        const argSkeletonFile = skeletonDataFile;
+        const argAtlasFile = atlasFile;
         let skeletonData, atlas, ownsSkeletonData;
         if (cc.isString(argSkeletonFile)) {
             if (cc.isString(argAtlasFile)) {
@@ -159,20 +138,16 @@ export class Skeleton extends cc.Node {
         this.setSkeletonData(skeletonData, ownsSkeletonData);
         this.init();
     }
-    /**
-     * Returns the bounding box of Skeleton.
-     * @returns {cc.Rect}
-     */
     getBoundingBox() {
         let minX = cc.FLT_MAX, minY = cc.FLT_MAX, maxX = cc.FLT_MIN, maxY = cc.FLT_MIN;
-        const scaleX = this.getScaleX(), scaleY = this.getScaleY(), slots = this._skeleton.slots, VERTEX = spine.RegionAttachment;
+        const scaleX = this.getScaleX(), scaleY = this.getScaleY(), slots = this._skeleton.slots, VERTEX = RegionAttachment;
         let vertices;
         for (let i = 0, slotCount = slots.length; i < slotCount; ++i) {
             const slot = slots[i];
             const attachment = slot.attachment;
-            if (!attachment || !(attachment instanceof spine.RegionAttachment))
+            if (!attachment || !(attachment instanceof RegionAttachment))
                 continue;
-            vertices = spine.Utils.setArraySize([], 8, 0);
+            vertices = 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);
@@ -182,115 +157,59 @@ export class Skeleton extends cc.Node {
         const 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() {
-        this._skeleton.updateWorldTransform(true);
+        this._skeleton.updateWorldTransform(Physics.pose);
     }
-    /**
-     * Sets the bones and slots to the setup pose.
-     */
     setToSetupPose() {
         this._skeleton.setToSetupPose();
     }
-    /**
-     * Sets the bones to the setup pose, using the values from the `BoneData` list in the `SkeletonData`.
-     */
     setBonesToSetupPose() {
         this._skeleton.setBonesToSetupPose();
     }
-    /**
-     * Sets the slots to the setup pose, using the values from the `SlotData` list in the `SkeletonData`.
-     */
     setSlotsToSetupPose() {
         this._skeleton.setSlotsToSetupPose();
     }
-    /**
-     * Finds a bone by name. This does a string comparison for every bone.
-     * @param {String} boneName
-     * @returns {.spine.Bone}
-     */
     findBone(boneName) {
         return this._skeleton.findBone(boneName);
     }
-    /**
-     * Finds a slot by name. This does a string comparison for every slot.
-     * @param {String} slotName
-     * @returns {.spine.Slot}
-     */
     findSlot(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 {.spine.Skin}
-     */
     setSkin(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 {.spine.Attachment}
-     */
     getAttachment(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(slotName, attachmentName) {
         this._skeleton.setAttachment(slotName, attachmentName);
     }
-    /**
-     * Sets the premultiplied alpha value to Skeleton.
-     * @param {Number} alpha
-     */
     setPremultipliedAlpha(premultiplied) {
         this._premultipliedAlpha = premultiplied;
     }
-    /**
-     * Returns whether to enable premultiplied alpha.
-     * @returns {boolean}
-     */
     isPremultipliedAlpha() {
         return this._premultipliedAlpha;
     }
-    /**
-     * Sets skeleton data to Skeleton.
-     * @param {.spine.SkeletonData} skeletonData
-     * @param {.spine.SkeletonData} ownsSkeletonData
-     */
     setSkeletonData(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._skeleton = new Skeleton(skeletonData);
+        this._skeleton.updateWorldTransform(Physics.pose);
         this._rootBone = this._skeleton.getRootBone();
         this._ownsSkeletonData = ownsSkeletonData;
-        this._renderCmd._createChildFormSkeletonData();
+        if (this._renderCmd && typeof this._renderCmd._createChildFormSkeletonData === 'function') {
+            this._renderCmd._createChildFormSkeletonData();
+        }
     }
-    /**
-     * Return the renderer of attachment.
-     * @param {.spine.RegionAttachment|.spine.BoundingBoxAttachment} regionAttachment
-     * @returns {.spine.TextureAtlasRegion}
-     */
     getTextureAtlas(regionAttachment) {
         return regionAttachment.region;
     }
-    /**
-     * Returns the blendFunc of Skeleton.
-     * @returns {cc.BlendFunc}
-     */
     getBlendFunc() {
         const slot = this._skeleton.drawOrder[0];
         if (slot) {
-            const blend = this._renderCmd._getBlendFunc(slot.data.blendMode, this._premultipliedAlpha);
+            const blend = this._renderCmd && typeof this._renderCmd._getBlendFunc === 'function'
+                ? this._renderCmd._getBlendFunc(slot.data.blendMode, this._premultipliedAlpha)
+                : {};
             return blend;
         }
         else {
@@ -300,21 +219,13 @@ export class Skeleton extends cc.Node {
     setBlendFunc() {
         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(dt) {
         this._skeleton.update(dt);
     }
-    // Static create method
-    static create(skeletonDataFile, atlasFile, scale) {
-        return new Skeleton(skeletonDataFile, atlasFile, scale);
-    }
 }
-cc.defineGetterSetter(Skeleton.prototype, 'opacityModifyRGB', Skeleton.prototype.isOpacityModifyRGB);
+cc.defineGetterSetter(CCSkeleton.prototype, 'opacityModifyRGB', CCSkeleton.prototype.isOpacityModifyRGB);
 // For renderer webgl to identify skeleton's default texture and blend function
-cc.defineGetterSetter(Skeleton.prototype, '_blendFunc', Skeleton.prototype.getBlendFunc);
-cc.defineGetterSetter(Skeleton.prototype, '_texture', function () {
+cc.defineGetterSetter(CCSkeleton.prototype, '_blendFunc', CCSkeleton.prototype.getBlendFunc);
+cc.defineGetterSetter(CCSkeleton.prototype, '_texture', function () {
     return this._renderCmd._currTexture;
 });