@safe-engine/cocos 1.0.1

package/dist/gworld/components/NodeComp.js

@@ -0,0 +1,425 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeComp = void 0;
+var remove_1 = __importDefault(require("lodash/remove"));
+var utils_1 = require("../../helper/utils");
+var polyfills_1 = require("../../polyfills");
+var NoRenderComponent_1 = require("./NoRenderComponent");
+var NodeComp = /** @class */ (function () {
+    function NodeComp(instance, entity) {
+        this.children = [];
+        this.entity = entity;
+        this.instance = instance;
+    }
+    Object.defineProperty(NodeComp.prototype, "uuid", {
+        get: function () {
+            return this.entity.id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "position", {
+        get: function () {
+            return this.getPosition();
+        },
+        set: function (val) {
+            this.setPosition(val.x, val.y);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "x", {
+        get: function () {
+            return this.instance.getPositionX();
+        },
+        set: function (val) {
+            this.instance.setPositionX(val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "y", {
+        get: function () {
+            return this.instance.getPositionY();
+        },
+        set: function (val) {
+            this.instance.setPositionY(val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "scale", {
+        get: function () {
+            return this.instance.getScale();
+        },
+        set: function (val) {
+            this.instance.setScale(val, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "scaleX", {
+        get: function () {
+            return this.instance.getScaleX();
+        },
+        set: function (val) {
+            this.instance.setScaleX(val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "scaleY", {
+        get: function () {
+            return this.instance.getScaleY();
+        },
+        set: function (val) {
+            this.instance.setScaleY(val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "anchorX", {
+        get: function () {
+            return this.instance.anchorX;
+        },
+        set: function (val) {
+            this.instance.anchorX = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "anchorY", {
+        get: function () {
+            return this.instance.anchorY;
+        },
+        set: function (val) {
+            this.instance.anchorY = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "rotation", {
+        /**
+         * Returns the rotation of the node in radians. 0 is the default rotation angle. Positive values rotate node clockwise.
+         * @function
+         * @return {Number} The rotation of the node in radians.
+         */
+        get: function () {
+            return cc.degreesToRadians(this.instance.getRotation());
+        },
+        /**
+         *
+         *  Sets the X rotation of the node in radians which performs a horizontal rotational skew.
+         *  (support only in WebGL rendering mode)
+         *  0 is the default rotation angle.
+         *  Positive values rotate node clockwise, and negative values for anti-clockwise.
+         *
+         * @param {Number} radians The X rotation in radians which performs a horizontal rotational skew.
+         */
+        set: function (val) {
+            this.instance.setRotation(cc.radiansToDegrees(val));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "angle", {
+        /**
+         * Returns the angle of the node in degrees. 0 is the default rotation angle. Positive values rotate node clockwise.
+         * @function
+         * @return {Number} The rotation of the node in degrees.
+         */
+        get: function () {
+            return this.instance.getRotation();
+        },
+        /**
+         *
+         *  Sets the X angle of the node in degrees which performs a horizontal rotational skew.
+         *  (support only in WebGL rendering mode)
+         *  0 is the default rotation angle.
+         *  Positive values rotate node clockwise, and negative values for anti-clockwise.
+         *
+         * @param {Number} degrees The X rotation in degrees which performs a horizontal rotational skew.
+         */
+        set: function (val) {
+            this.instance.setRotation(val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "color", {
+        get: function () {
+            return this.instance.getColor();
+        },
+        set: function (val) {
+            this.instance.setColor(val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "opacity", {
+        get: function () {
+            return this.instance.getOpacity();
+        },
+        set: function (val) {
+            this.instance.setOpacity(val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "active", {
+        get: function () {
+            return cc.sys.isObjectValid(this.instance) && this.instance.visible;
+        },
+        set: function (val) {
+            if (!cc.sys.isObjectValid(this.instance)) {
+                return;
+            }
+            if (this.instance instanceof ccui.Widget) {
+                this.instance.setEnabled(val);
+            }
+            this.instance.setVisible(val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "group", {
+        get: function () {
+            return this._group;
+        },
+        set: function (val) {
+            this._group = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "width", {
+        get: function () {
+            return this.instance.width;
+        },
+        set: function (val) {
+            this.instance.setContentSize(val, this.height);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "height", {
+        get: function () {
+            return this.instance.height;
+        },
+        set: function (val) {
+            this.instance.setContentSize(val, this.width);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "zIndex", {
+        get: function () {
+            return this.instance.zIndex;
+        },
+        set: function (val) {
+            this.instance.zIndex = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "childrenCount", {
+        get: function () {
+            return this.children.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    NodeComp.prototype.destroy = function () {
+        this.removeFromParent(true);
+    };
+    NodeComp.prototype.addComponent = function (instance) {
+        return this.entity.assign(instance);
+    };
+    NodeComp.prototype.getComponent = function (component) {
+        return this.entity.getComponent(component);
+    };
+    NodeComp.prototype.getComponentsInChildren = function (component) {
+        if (!this.children.length) {
+            return [];
+        }
+        var listHave = this.children.filter(function (child) {
+            return child.getComponent(component);
+        });
+        return listHave.map(function (node) { return node.getComponent(component); });
+    };
+    NodeComp.prototype.getComponentInChildren = function (component) {
+        return this.getComponentsInChildren(component)[0];
+    };
+    NodeComp.prototype.hasComponentInChildren = function (component) {
+        if (!this.children.length) {
+            return false;
+        }
+        return this.children.some(function (child) {
+            return child.getComponent(component);
+        });
+    };
+    NodeComp.prototype.getPercent = function () {
+        if (this.instance instanceof ccui.LoadingBar) {
+            return this.instance.getPercent();
+        }
+        return 0;
+    };
+    NodeComp.prototype.setPercent = function (val) {
+        if (this.instance instanceof ccui.LoadingBar) {
+            return this.instance.setPercent(val);
+        }
+    };
+    NodeComp.prototype.setTouchEnabled = function (enabled) {
+        if (!cc.sys.isObjectValid(this.instance)) {
+            return;
+        }
+        if (this.instance instanceof ccui.Widget) {
+            this.instance.setTouchEnabled(enabled);
+        }
+    };
+    NodeComp.prototype.addTouchEventListener = function (cb) {
+        if (!cc.sys.isObjectValid(this.instance)) {
+            return;
+        }
+        if (this.instance instanceof ccui.Widget) {
+            this.instance.addTouchEventListener(cb);
+        }
+    };
+    NodeComp.prototype.convertToNodeSpace = function (point) {
+        var _a = this.instance.convertToNodeSpace(point), x = _a.x, y = _a.y;
+        return (0, polyfills_1.Vec2)(x, y);
+    };
+    NodeComp.prototype.convertToNodeSpaceAR = function (point) {
+        var _a = this.instance.convertToNodeSpaceAR(point), x = _a.x, y = _a.y;
+        return (0, polyfills_1.Vec2)(x, y);
+    };
+    NodeComp.prototype.convertToWorldSpaceAR = function (point) {
+        var _a = this.instance.convertToWorldSpaceAR(point), x = _a.x, y = _a.y;
+        return (0, polyfills_1.Vec2)(x, y);
+    };
+    NodeComp.prototype.getPosition = function () {
+        return (0, polyfills_1.Vec2)(this.x, this.y);
+    };
+    NodeComp.prototype.setPosition = function (x, y) {
+        if (typeof x !== 'number') {
+            this.x = x.x;
+            this.y = x.y;
+        }
+        else {
+            this.x = x;
+            this.y = y;
+        }
+    };
+    NodeComp.prototype.setRotation = function (deg) {
+        this.instance.setRotation(deg);
+    };
+    NodeComp.prototype.getRotation = function () {
+        return this.instance.getRotation();
+    };
+    NodeComp.prototype.setAnchorPoint = function (point, y) {
+        this.instance.setAnchorPoint(point, y);
+    };
+    NodeComp.prototype.getAnchorPoint = function () {
+        return this.instance.getAnchorPoint();
+    };
+    NodeComp.prototype.getBoundingBox = function () {
+        var box = this.instance.getBoundingBox();
+        box.contains = function (point) {
+            return this.x <= point.x && this.x + this.width >= point.x && this.y <= point.y && this.y + this.height >= point.y;
+        };
+        return box;
+    };
+    NodeComp.prototype.getContentSize = function () {
+        return this.instance.getContentSize();
+    };
+    NodeComp.prototype.setContentSize = function (size, height) {
+        this.instance.setContentSize(size, height);
+        if (this.instance instanceof cc.ClippingNode) {
+            var hw = (size.width || size) * 0.5;
+            var hh = (size.height || height) * 0.5;
+            var stencil = new cc.DrawNode();
+            var rectangle = [cc.p(-hw, -hh), cc.p(hw, -hh), cc.p(hw, hh), cc.p(-hw, hh)];
+            stencil.drawPoly(rectangle, cc.Color.WHITE, 0, cc.Color.WHITE);
+            // stencil.drawDot(cc.p(-height * 0.5, -height * 0.5), height, cc.Color.WHITE);
+            this.instance.stencil = stencil;
+        }
+    };
+    NodeComp.prototype.setColor = function (color) {
+        this.instance.setColor(color);
+    };
+    NodeComp.prototype.setScale = function (scaleX, scaleY) {
+        this.instance.setScale(scaleX, scaleY || scaleX);
+    };
+    NodeComp.prototype.runAction = function (atc) {
+        this.instance.runAction(atc);
+    };
+    NodeComp.prototype.stopAllActions = function () {
+        this.instance.stopAllActions();
+    };
+    NodeComp.prototype.pauseAllActionsAndSchedule = function () {
+        this.instance.pause();
+        this.instance.unscheduleUpdate();
+    };
+    NodeComp.prototype.resumeAllActionsAndSchedule = function () {
+        this.instance.resume();
+        this.instance.scheduleUpdate();
+    };
+    NodeComp.prototype.removeFromParent = function (cleanup) {
+        var _this = this;
+        if (this.parent) {
+            (0, remove_1.default)(this.parent.children, function (_a) {
+                var entity = _a.entity;
+                return entity.id === _this.entity.id;
+            });
+        }
+        if (cleanup) {
+            this.children.forEach(function (child) {
+                child.entity.destroy();
+            });
+            this.parent = null;
+            this.entity.destroy();
+            this.instance.removeFromParent(cleanup);
+        }
+        else {
+            this.active = false;
+            this.stopAllActions();
+            this.instance.removeFromParent();
+        }
+    };
+    NodeComp.prototype.addChild = function (child) {
+        child.parent = this;
+        this.children.push(child);
+        this.instance.addChild(child.instance);
+    };
+    NodeComp.prototype.removeAllChildren = function (cleanup) {
+        this.instance.removeAllChildren(cleanup);
+    };
+    NodeComp.prototype.getData = function (key) {
+        var data = this.getComponent(NoRenderComponent_1.ExtraDataComp);
+        if (!data)
+            throw Error('need add ExtraDataComp to Node');
+        return data.getData(key);
+    };
+    NodeComp.prototype.setData = function (key, value) {
+        var data = this.getComponent(NoRenderComponent_1.ExtraDataComp);
+        if (!data) {
+            this.addComponent((0, utils_1.instantiate)(NoRenderComponent_1.ExtraDataComp, { key: key, value: value }));
+        }
+        else {
+            data.setData(key, value);
+        }
+    };
+    NodeComp.prototype.resolveComponent = function (component) {
+        if (component.constructor.hasRender) {
+            this.addChild(component.node);
+        }
+        else {
+            this.addComponent(component);
+        }
+    };
+    return NodeComp;
+}());
+exports.NodeComp = NodeComp;

package/dist/gworld/components/RenderComponent.d.ts

@@ -0,0 +1,53 @@
+import { GraphicsRenderProps, SpineData } from '../../../@types/safex';
+import { ComponentX } from '../core/decorator';
+export declare class NodeRender extends ComponentX {
+    nodeName: string;
+}
+interface SpriteRenderProps {
+    spriteFrame: string;
+    texType?: number;
+    type?: number;
+}
+export declare class SpriteRender extends ComponentX<SpriteRenderProps & {
+    $ref?: SpriteRender;
+}, cc.Sprite> {
+    get spriteFrame(): string;
+    set spriteFrame(frame: string);
+}
+interface MaskRenderProps {
+    type?: number;
+    segments?: number;
+    inverted?: boolean;
+}
+export declare class MaskRender extends ComponentX<MaskRenderProps, cc.ClippingNode> {
+}
+export declare class ParticleComp extends ComponentX<cc.ParticleSystem> {
+    plistFile: string;
+}
+interface SpineSkeletonProps {
+    data: SpineData;
+    skin?: string;
+    animation?: string;
+    timeScale?: number;
+    loop?: boolean;
+}
+export declare class SpineSkeleton extends ComponentX<SpineSkeletonProps & {
+    $ref: SpineSkeleton;
+}> {
+    data: SpineData;
+    skin: string;
+    animation: string;
+    loop: boolean;
+    timeScale: number;
+    setAnimation(name: string, loop?: boolean): void;
+    setSkeletonData(data: string): void;
+}
+export declare class GraphicsRender extends ComponentX<GraphicsRenderProps, cc.DrawNode> {
+    lineWidth: number;
+    strokeColor: cc.Color;
+    fillColor: cc.Color;
+    circle(x: any, y: any, r: any): void;
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=RenderComponent.d.ts.map

package/dist/gworld/components/RenderComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderComponent.d.ts","sourceRoot":"","sources":["../../../src/gworld/components/RenderComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEtE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,qBAAa,UAAW,SAAQ,UAAU;IACxC,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,iBAAiB;IACzB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,qBAAa,YAAa,SAAQ,UAAU,CAAC,iBAAiB,GAAG;IAAE,IAAI,CAAC,EAAE,YAAY,CAAA;CAAE,EAAE,EAAE,CAAC,MAAM,CAAC;IAClG,IAAI,WAAW,WAEd;IAED,IAAI,WAAW,CAAC,KAAK,QAAA,EAepB;CACF;AACD,UAAU,eAAe;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AACD,qBAAa,UAAW,SAAQ,UAAU,CAAC,eAAe,EAAE,EAAE,CAAC,YAAY,CAAC;CAAG;AAE/E,qBAAa,YAAa,SAAQ,UAAU,CAAC,EAAE,CAAC,cAAc,CAAC;IAC7D,SAAS,EAAE,MAAM,CAAA;CAClB;AACD,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;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC;IACzF,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IAEjB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,UAAQ;IAOvC,eAAe,CAAC,IAAI,EAAE,MAAM;CAK7B;AAED,qBAAa,cAAe,SAAQ,UAAU,CAAC,mBAAmB,EAAE,EAAE,CAAC,QAAQ,CAAC;IAC9E,SAAS,SAAI;IACb,WAAW,WAAM;IACjB,SAAS,WAAO;IAEhB,MAAM,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,CAAC,KAAA;IAwDd,KAAK;CAKN"}

package/dist/gworld/components/RenderComponent.js

@@ -0,0 +1,158 @@
+"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.GraphicsRender = exports.SpineSkeleton = exports.ParticleComp = exports.MaskRender = exports.SpriteRender = exports.NodeRender = void 0;
+var polyfills_1 = require("../../polyfills");
+var decorator_1 = require("../core/decorator");
+var NodeRender = /** @class */ (function (_super) {
+    __extends(NodeRender, _super);
+    function NodeRender() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return NodeRender;
+}(decorator_1.ComponentX));
+exports.NodeRender = NodeRender;
+var SpriteRender = /** @class */ (function (_super) {
+    __extends(SpriteRender, _super);
+    function SpriteRender() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(SpriteRender.prototype, "spriteFrame", {
+        get: function () {
+            return this.props.spriteFrame;
+        },
+        set: function (frame) {
+            this.props.spriteFrame = frame;
+            if (this.node && this.node.instance instanceof cc.Sprite) {
+                this.node.instance.setTexture(frame);
+            }
+            // } else if (this.node.instance instanceof ccui.ImageView) {
+            //   if (this.texType) {
+            //     this.node.instance.loadTexture(frame, this.texType)
+            //   } else {
+            //     this.node.instance.loadTexture(frame)
+            //   }
+            //   const sprite = new cc.Sprite(frame)
+            //   this.node.setContentSize(sprite.getContentSize())
+            // } else if (this.node.instance instanceof ccui.Button) {
+            //   this.node.instance.loadTextureNormal(frame)
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return SpriteRender;
+}(decorator_1.ComponentX));
+exports.SpriteRender = SpriteRender;
+var MaskRender = /** @class */ (function (_super) {
+    __extends(MaskRender, _super);
+    function MaskRender() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return MaskRender;
+}(decorator_1.ComponentX));
+exports.MaskRender = MaskRender;
+var ParticleComp = /** @class */ (function (_super) {
+    __extends(ParticleComp, _super);
+    function ParticleComp() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return ParticleComp;
+}(decorator_1.ComponentX));
+exports.ParticleComp = ParticleComp;
+var SpineSkeleton = /** @class */ (function (_super) {
+    __extends(SpineSkeleton, _super);
+    function SpineSkeleton() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpineSkeleton.prototype.setAnimation = function (name, loop) {
+        if (loop === void 0) { loop = false; }
+        var skel = this.node.instance;
+        if (skel.setAnimation) {
+            skel.setAnimation(0, name, loop);
+        }
+    };
+    SpineSkeleton.prototype.setSkeletonData = function (data) {
+        var skel = this.node.instance;
+        var atlas = data.replace('.json', '.atlas');
+        skel.initWithArgs(data, atlas, this.node.scale);
+    };
+    return SpineSkeleton;
+}(decorator_1.ComponentX));
+exports.SpineSkeleton = SpineSkeleton;
+var GraphicsRender = /** @class */ (function (_super) {
+    __extends(GraphicsRender, _super);
+    function GraphicsRender() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.lineWidth = 5;
+        _this.strokeColor = polyfills_1.RED;
+        _this.fillColor = polyfills_1.BLUE;
+        return _this;
+    }
+    GraphicsRender.prototype.circle = function (x, y, r) {
+        if (this.node.instance instanceof cc.DrawNode) {
+            this.node.instance.drawDot(cc.p(x, y), r, this.fillColor);
+        }
+    };
+    // fill() { }
+    // stroke() { }
+    // drawPoint(position: Vec2, pointSize: Float, color:  Color4B, pointType = PointType.Rect) {
+    // }
+    // // drawPoints(points: Vec2[], color: Color4B) {
+    // // }
+    // drawLine(origin: Vec2, destination: Vec2, color: Color4B, thickness: Float) {
+    // }
+    // drawRect(origin: Vec2, destination: Vec2, color: Color4B) {
+    //   this.node.instance.drawRect(origin, destination, color)
+    // }
+    // drawSolidRect(origin: Vec2, destination: Vec2, color: Color4B) {
+    // }
+    // drawCircle(center: Vec2, radius: Float, angle?: Float, segments?: Integer, drawLineToCenter?: boolean, scaleX?: Float, scaleY?: Float, color?: Color4B, thickness?: Float) {
+    //   this.node.instance.drawCircle(x, y, radius)
+    // }
+    // drawSolidCircle(origin: Vec2, destination: Vec2, color: Color4B) {
+    // }
+    // drawQuadBezier(origin: Vec2, destination: Vec2, color: Color4B) {
+    // }
+    // drawCubicBezier(origin: Vec2, destination: Vec2, color: Color4B) {
+    // }
+    // drawCardinalSpline(points: Vec2[], color: Color4B) {
+    // }
+    // drawCatmullRom(points: Vec2[], color: Color4B) {
+    // }
+    // drawPoly(points: Vec2[], closedPolygon: boolean, color: Color4B, thickness?: Float) {
+    //   this.node.instance.poly(points, closedPolygon)
+    //   this.node.instance.fill(color)
+    // }
+    // drawSolidPoly(points: Vec2[], color: Color4B) {
+    //   this.node.instance.drawPoly(points, color)
+    // }
+    // drawDot(points: Vec2[], color: Color4B) {
+    // }
+    // drawSegment(from: Vec2, to: Vec2, color: Color4B) {
+    // }
+    // drawTriangle(p1: Vec2, p2: Vec2, p3: Vec2, color: Color4B) {
+    //   this.node.instance.poly([p1, p2, p3], true)
+    //   this.node.instance.fill(color)
+    // }
+    GraphicsRender.prototype.clear = function () {
+        if (this.node.instance instanceof cc.DrawNode) {
+            this.node.instance.clear();
+        }
+    };
+    return GraphicsRender;
+}(decorator_1.ComponentX));
+exports.GraphicsRender = GraphicsRender;

package/dist/gworld/core/Scene.d.ts

@@ -0,0 +1,5 @@
+import { EnhancedComponent } from '../components/EnhancedComponent';
+export declare class SceneComponent extends EnhancedComponent {
+    render(): this;
+}
+//# sourceMappingURL=Scene.d.ts.map

package/dist/gworld/core/Scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../src/gworld/core/Scene.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AAGnE,qBAAa,cAAe,SAAQ,iBAAiB;IACnD,MAAM;CASP"}

package/dist/gworld/core/Scene.js

@@ -0,0 +1,38 @@
+"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.SceneComponent = void 0;
+var __1 = require("..");
+var EnhancedComponent_1 = require("../components/EnhancedComponent");
+var NodeComp_1 = require("../components/NodeComp");
+var SceneComponent = /** @class */ (function (_super) {
+    __extends(SceneComponent, _super);
+    function SceneComponent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SceneComponent.prototype.render = function () {
+        var world = __1.GameWorld.Instance;
+        world.entities.reset();
+        var root = world.entities.create();
+        var node = root.assign(new NodeComp_1.NodeComp(cc.director.getRunningScene(), root));
+        var sceneComponent = root.assign(this);
+        sceneComponent.node = node;
+        return sceneComponent;
+    };
+    return SceneComponent;
+}(EnhancedComponent_1.EnhancedComponent));
+exports.SceneComponent = SceneComponent;