@safe-engine/cocos 2.2.7 → 2.3.4

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/{CCSkeletonTexture.d.ts → spine-cocos/CCSkeletonTexture.d.ts}

@@ -21,5 +21,5 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ****************************************************************************/
-export declare const SkeletonTexture: (image: any) => void;
+export declare const SkeletonTexture: () => 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;AAI9E,eAAO,MAAM,eAAe,YAE3B,CAAA"}

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

@@ -1,4 +1,3 @@
-import * as spine from '@esotericsoftware/spine-core';
 /****************************************************************************
  Copyright (c) 2017 Chukong Technologies Inc.
 
@@ -22,12 +21,13 @@ import * as spine from '@esotericsoftware/spine-core';
  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)
+import { Texture } from '@esotericsoftware/spine-core';
+export const SkeletonTexture = function () {
+    // Texture.call(this, image);
 };
-cc.inherits(SkeletonTexture, spine.Texture);
+cc.inherits(SkeletonTexture, Texture);
 cc.extend(SkeletonTexture.prototype, {
-    name: 'gworld.SkeletonTexture',
+    name: 'SkeletonTexture',
     _texture: null,
     setRealTexture: function (tex) {
         this._texture = tex;

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

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

@@ -1,4 +1,3 @@
-import * as spine from '@esotericsoftware/spine-core';
 /****************************************************************************
  Copyright (c) 2013-2014 Chukong Technologies Inc.
 
@@ -22,6 +21,7 @@ import * as spine from '@esotericsoftware/spine-core';
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ****************************************************************************/
+import { BlendMode, MeshAttachment, RegionAttachment, Utils } from '@esotericsoftware/spine-core';
 export const WebGLRenderCmd = function (renderableObject) {
     this._rootCtor(renderableObject);
     this._needDraw = true;
@@ -59,10 +59,10 @@ proto.uploadData = function (f32buffer, ui32buffer, vertexDataOffset) {
         attachment = slot.attachment;
         // get the vertices length
         let vertCount = 0;
-        if (attachment instanceof spine.RegionAttachment) {
+        if (attachment instanceof RegionAttachment) {
             vertCount = 6; // a quad = two triangles = six vertices
         }
-        else if (attachment instanceof spine.MeshAttachment) {
+        else if (attachment instanceof MeshAttachment) {
             vertCount = attachment.regionUVs.length / 2;
         }
         else {
@@ -92,10 +92,10 @@ proto.uploadData = function (f32buffer, ui32buffer, vertexDataOffset) {
         }
         // update the vertex buffer
         let slotDebugPoints = null;
-        if (attachment instanceof spine.RegionAttachment) {
+        if (attachment instanceof RegionAttachment) {
             slotDebugPoints = this._uploadRegionAttachmentData(attachment, slot, premultiAlpha, f32buffer, ui32buffer, vertexDataOffset);
         }
-        else if (attachment instanceof spine.MeshAttachment) {
+        else if (attachment instanceof MeshAttachment) {
             this._uploadMeshAttachmentData(attachment, slot, premultiAlpha, f32buffer, ui32buffer, vertexDataOffset);
         }
         else {
@@ -105,7 +105,7 @@ proto.uploadData = function (f32buffer, ui32buffer, vertexDataOffset) {
             debugSlotsInfo[i] = slotDebugPoints;
         }
         // update the index buffer
-        if (attachment instanceof spine.RegionAttachment) {
+        if (attachment instanceof RegionAttachment) {
             cc.renderer._increaseBatchingSize(vertCount, cc.renderer.VertexType.TRIANGLE);
         }
         else {
@@ -168,19 +168,19 @@ proto.uploadData = function (f32buffer, ui32buffer, vertexDataOffset) {
 proto._getBlendFunc = function (blendMode, premultiAlpha) {
     let ret = this._currBlendFunc;
     switch (blendMode) {
-        case spine.BlendMode.Normal:
+        case BlendMode.Normal:
             ret.src = premultiAlpha ? cc.ONE : cc.SRC_ALPHA;
             ret.dst = cc.ONE_MINUS_SRC_ALPHA;
             break;
-        case spine.BlendMode.Additive:
+        case BlendMode.Additive:
             ret.src = premultiAlpha ? cc.ONE : cc.SRC_ALPHA;
             ret.dst = cc.ONE;
             break;
-        case spine.BlendMode.Multiply:
+        case BlendMode.Multiply:
             ret.src = cc.DST_COLOR;
             ret.dst = cc.ONE_MINUS_SRC_ALPHA;
             break;
-        case spine.BlendMode.Screen:
+        case BlendMode.Screen:
             ret.src = cc.ONE;
             ret.dst = cc.ONE_MINUS_SRC_COLOR;
             break;
@@ -203,7 +203,7 @@ proto._uploadRegionAttachmentData = function (attachment, slot, premultipliedAlp
     //
     const nodeColor = this._displayedColor;
     const nodeR = nodeColor.r, nodeG = nodeColor.g, nodeB = nodeColor.b, nodeA = this._displayedOpacity;
-    const vertices = spine.Utils.setArraySize([], 8, 0);
+    const vertices = Utils.setArraySize([], 8, 0);
     attachment.computeWorldVertices(slot, vertices, 0, 2);
     const uvs = attachment.uvs;
     // get the colors data
@@ -235,7 +235,7 @@ proto._uploadRegionAttachmentData = function (attachment, slot, premultipliedAlp
     }
     if (this._node._debugSlots) {
         // return the quad points info if debug slot enabled
-        const VERTEX = spine.RegionAttachment;
+        const VERTEX = RegionAttachment;
         return [
             cc.p(vertices[VERTEX.X1], vertices[VERTEX.Y1]),
             cc.p(vertices[VERTEX.X2], vertices[VERTEX.Y2]),
@@ -248,7 +248,7 @@ proto._uploadMeshAttachmentData = function (attachment, slot, premultipliedAlpha
     const wt = this._worldTransform, wa = wt.a, wb = wt.b, wc = wt.c, wd = wt.d, wx = wt.tx, wy = wt.ty, z = this._node.vertexZ;
     // get the vertex data
     const verticesLength = attachment.worldVerticesLength;
-    const vertices = spine.Utils.setArraySize([], verticesLength, 0);
+    const vertices = Utils.setArraySize([], verticesLength, 0);
     attachment.computeWorldVertices(slot, 0, verticesLength, vertices, 0, 2);
     const uvs = attachment.uvs;
     // get the colors data

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safe-engine/cocos",
-  "version": "2.2.7",
+  "version": "2.3.4",
   "description": "safe-engine with cocos renderer support",
   "type": "module",
   "main": "dist/index.js",
@@ -21,12 +21,11 @@
     "typescript": "^5.9.2"
   },
   "dependencies": {
-    "@esotericsoftware/spine-pixi-v8": "^4.2.90",
+    "@cocos/dragonbones-js": "^1.0.2",
+    "@esotericsoftware/spine-core": "^4.2.93",
     "box2d-wasm": "^7.0.0",
-    "cocos-html5-ts": "^1.2.2",
-    "dragonbones-pixijs": "^1.0.5",
-    "entityx-ts": "^2.3.1",
-    "pixi.js": "^8.13.2"
+    "cocos-html5-ts": "^1.2.4",
+    "entityx-ts": "^2.3.1"
   },
   "author": "",
   "license": "ISC"

package/dist/core/index.d.ts

@@ -1,6 +0,0 @@
-export * from './decorator';
-export * from './EnhancedComponent';
-export * from './NodeComp';
-export * from './NodePool';
-export * from './Scene';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,qBAAqB,CAAA;AACnC,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA"}

package/dist/core/index.js

@@ -1,5 +0,0 @@
-export * from './decorator';
-export * from './EnhancedComponent';
-export * from './NodeComp';
-export * from './NodePool';
-export * from './Scene';

package/dist/dragonbones/PixiDragonBonesSprite.d.ts

@@ -1,15 +0,0 @@
-import { PixiArmatureDisplay } from 'dragonbones-pixijs';
-import { Application } from 'pixi.js';
-export declare function loadDragonBonesAssets(skeleton: any, atlas: any, texture: any): Promise<any>;
-export declare class PixiDragonBonesSprite extends cc.Sprite {
-    _canvas: any;
-    _pixiApp: Application;
-    _texture: cc.Texture2D;
-    _config: any;
-    _armatureDisplay: PixiArmatureDisplay;
-    constructor(config: any);
-    _setupArmature(): void;
-    updateTexture(): void;
-    onExit(): void;
-}
-//# sourceMappingURL=PixiDragonBonesSprite.d.ts.map

package/dist/dragonbones/PixiDragonBonesSprite.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PixiDragonBonesSprite.d.ts","sourceRoot":"","sources":["../../src/dragonbones/PixiDragonBonesSprite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAe,MAAM,oBAAoB,CAAA;AACrE,OAAO,EAAE,WAAW,EAAU,MAAM,SAAS,CAAA;AAE7C,wBAAgB,qBAAqB,CAAC,QAAQ,KAAA,EAAE,KAAK,KAAA,EAAE,OAAO,KAAA,gBAE7D;AACD,qBAAa,qBAAsB,SAAQ,EAAE,CAAC,MAAM;IAClD,OAAO,EAAE,GAAG,CAAA;IACZ,QAAQ,EAAE,WAAW,CAAA;IACrB,QAAQ,EAAE,EAAE,CAAC,SAAS,CAAA;IACtB,OAAO,MAAA;IACP,gBAAgB,EAAE,mBAAmB,CAAA;gBACzB,MAAM,KAAA;IA+BlB,cAAc;IAsBd,aAAa;IASb,MAAM;CAMP"}

package/dist/dragonbones/PixiDragonBonesSprite.js

@@ -1,71 +0,0 @@
-import { PixiFactory } from 'dragonbones-pixijs';
-import { Application, Assets } from 'pixi.js';
-export function loadDragonBonesAssets(skeleton, atlas, texture) {
-    return Assets.load([skeleton, atlas, texture]);
-}
-export class PixiDragonBonesSprite extends cc.Sprite {
-    _canvas;
-    _pixiApp;
-    _texture;
-    _config;
-    _armatureDisplay;
-    constructor(config) {
-        super();
-        super.ctor(); // always call this for compatibility with cocos2dx JS Javascript class system
-        this._canvas = document.createElement('canvas');
-        this._canvas.width = config.width || 1024;
-        this._canvas.height = config.height || 1024;
-        this._pixiApp = new Application();
-        this._pixiApp.init({
-            view: this._canvas,
-            width: this._canvas.width,
-            height: this._canvas.height,
-            backgroundAlpha: 0, // nền trong suốt
-            // transparent: true, // bắt buộc để alpha hoạt động
-            clearBeforeRender: true, // xoá trước khi vẽ frame mới
-            preserveDrawingBuffer: true, // giúp lấy ảnh từ canvas
-            antialias: true,
-        });
-        this._texture = new cc.Texture2D();
-        this._texture.initWithElement(this._canvas);
-        this._texture.handleLoadedTexture();
-        this.initWithTexture(this._texture);
-        this._config = config;
-        this._armatureDisplay = null;
-        this._setupArmature();
-        // this.schedule(this.updateTexture, 1 / 30);
-    }
-    _setupArmature() {
-        const { key, skeleton, atlas, texture, playTimes, animationName, scale = 1 } = this._config;
-        const factory = PixiFactory.factory;
-        const dragonData = factory.parseDragonBonesData(Assets.get(skeleton), key);
-        factory.parseTextureAtlasData(Assets.get(atlas), Assets.get(texture), key);
-        const { armatureNames } = dragonData;
-        const armatureName = armatureNames[0];
-        const display = factory.buildArmatureDisplay(armatureName, key);
-        if (!display) {
-            console.error('Cannot build armature:', armatureName);
-            return;
-        }
-        display.animation.play(animationName, playTimes);
-        display.x = this._canvas.width / 2;
-        display.y = this._canvas.height / 2;
-        display.scale.set(scale);
-        this._pixiApp.stage.addChild(display);
-        this._armatureDisplay = display;
-    }
-    updateTexture() {
-        if (this._armatureDisplay && this._pixiApp.renderer) {
-            this._pixiApp.renderer.render(this._pixiApp.stage);
-            this._texture.initWithElement(this._canvas);
-            this._texture.handleLoadedTexture();
-            this.setTexture(this._texture);
-        }
-    }
-    onExit() {
-        // this.unschedule(this.updateTexture);
-        this._pixiApp.destroy(true, { children: true });
-        this._canvas.remove();
-        super.onExit();
-    }
-}

package/dist/gworld/EnhancedComponent.d.ts

@@ -1,22 +0,0 @@
-import { Constructor } from 'entityx-ts';
-import { BaseComponentProps } from '../safex';
-import { NodeComp } from './NodeComp';
-export declare class EnhancedComponent<Props = object, N extends NodeComp<any> = NodeComp<any>> {
-    static hasRender: boolean;
-    props: Props;
-    node: N;
-    enabled: boolean;
-    constructor(data?: BaseComponentProps<EnhancedComponent> & Props);
-    init(data?: Props): void;
-    addComponent<T extends EnhancedComponent>(instance: T): T;
-    getComponent<T extends EnhancedComponent>(component: Constructor<T>): T;
-    schedule(callback: (arg: any) => void, interval: number, repeat?: number, delay?: number): void;
-    unschedule(callback: (arg: any) => void): void;
-    unscheduleAllCallbacks(): void;
-    scheduleOnce(callback: (arg: any) => void, delay: number, key?: string): void;
-    getComponentsInChildren<T extends ComponentType>(component: Constructor<T>): T[];
-    getComponentInChildren<T extends ComponentType>(component: Constructor<T>): T;
-    isEqual(other: EnhancedComponent): boolean;
-}
-export type ComponentType = EnhancedComponent | NodeComp;
-//# sourceMappingURL=EnhancedComponent.d.ts.map

package/dist/gworld/EnhancedComponent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"EnhancedComponent.d.ts","sourceRoot":"","sources":["../../src/gworld/EnhancedComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAExC,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,qBAAa,iBAAiB,CAAC,KAAK,GAAG,MAAM,EAAE,CAAC,SAAS,QAAQ,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC;IACpF,MAAM,CAAC,SAAS,UAAO;IACvB,KAAK,EAAE,KAAK,CAAY;IACxB,IAAI,EAAE,CAAC,CAAA;IACP,OAAO,UAAO;gBACF,IAAI,CAAC,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,GAAG,KAAK;IAGhE,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK;IASjB,YAAY,CAAC,CAAC,SAAS,iBAAiB,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC;IAGzD,YAAY,CAAC,CAAC,SAAS,iBAAiB,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC;IAGvE,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAE,MAAgC,EAAE,KAAK,SAAI;IAG5G,UAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI;IAGvC,sBAAsB;IAGtB,YAAY,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAGtE,uBAAuB,CAAC,CAAC,SAAS,aAAa,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;IAGhF,sBAAsB,CAAC,CAAC,SAAS,aAAa,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC;IAG7E,OAAO,CAAC,KAAK,EAAE,iBAAiB;CAGjC;AAED,MAAM,MAAM,aAAa,GAAG,iBAAiB,GAAG,QAAQ,CAAA"}

package/dist/gworld/EnhancedComponent.js

@@ -1,44 +0,0 @@
-export class EnhancedComponent {
-    static hasRender = true;
-    props = {};
-    node;
-    enabled = true;
-    constructor(data) {
-        this.init(data);
-    }
-    init(data) {
-        if (data) {
-            // console.log('constructor', this.constructor.name, data)
-            Object.keys(data).forEach((key) => {
-                this.props[key] = data[key];
-            });
-        }
-    }
-    addComponent(instance) {
-        return this.node.addComponent(instance);
-    }
-    getComponent(component) {
-        return this.node.getComponent(component);
-    }
-    schedule(callback, interval, repeat = cc.macro.REPEAT_FOREVER, delay = 0) {
-        this.node.instance.schedule(callback.bind(this), interval, repeat, delay);
-    }
-    unschedule(callback) {
-        this.node.instance.unschedule(callback.bind(this));
-    }
-    unscheduleAllCallbacks() {
-        this.node.instance.unscheduleAllCallbacks();
-    }
-    scheduleOnce(callback, delay, key) {
-        this.node.instance.scheduleOnce(callback, delay, key);
-    }
-    getComponentsInChildren(component) {
-        return this.node.getComponentsInChildren(component);
-    }
-    getComponentInChildren(component) {
-        return this.node.getComponentInChildren(component);
-    }
-    isEqual(other) {
-        return this.node.entity.id === other.node.entity.id;
-    }
-}