@safe-engine/pixi 1.0.0

package/dist/components/NodeComp.js

@@ -0,0 +1,420 @@
+"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 pixi_js_1 = require("pixi.js");
+var pixi_action_ease_1 = require("pixi-action-ease");
+var GUIComponent_1 = require("./GUIComponent");
+var NodeComp = /** @class */ (function () {
+    function NodeComp(instance, entity) {
+        this.events = {};
+        this.data = {};
+        this.children = [];
+        this.actionsList = [];
+        this._group = 0;
+        this.entity = entity;
+        this.instance = instance;
+        this.instance.eventMode = 'static';
+    }
+    NodeComp.prototype.setOnTouchStart = function (cb) {
+        var _this = this;
+        this.onTouchStart = cb;
+        this.instance.on('touchstart', function (event) {
+            var global = event.global;
+            _this.onTouchStart({ location: global });
+        });
+    };
+    NodeComp.prototype.setOnTouchMove = function (cb) {
+        var _this = this;
+        this.onTouchMove = cb;
+        this.instance.on('touchmove', function (event) {
+            var global = event.global;
+            _this.onTouchMove({ location: global });
+        });
+    };
+    NodeComp.prototype.setOnTouchEnd = function (cb) {
+        var _this = this;
+        this.onTouchEnd = cb;
+        this.instance.on('touchend', function (event) {
+            var global = event.global;
+            _this.onTouchEnd({ location: global });
+        });
+    };
+    NodeComp.prototype.setOnTouchCancel = function (cb) {
+        var _this = this;
+        this.onTouchCancel = cb;
+        this.instance.on('touchcancel', function (event) {
+            var global = event.global;
+            _this.onTouchCancel({ location: global });
+        });
+    };
+    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.x;
+        },
+        set: function (val) {
+            this.instance.x = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "y", {
+        get: function () {
+            return this.instance.y;
+        },
+        set: function (val) {
+            this.instance.y = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "scale", {
+        // get scale() {
+        //   return this.instance.scale
+        // }
+        set: function (val) {
+            this.instance.scale = new pixi_js_1.Point(val, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "scaleX", {
+        get: function () {
+            return this.instance.scale.x;
+        },
+        set: function (val) {
+            this.instance.scale.x = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "scaleY", {
+        get: function () {
+            return this.instance.y;
+        },
+        set: function (val) {
+            this.instance.y = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "anchorX", {
+        get: function () {
+            return this.instance.anchor.x;
+        },
+        set: function (val) {
+            if (this.instance instanceof pixi_js_1.Sprite)
+                this.instance.anchor.x = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "anchorY", {
+        get: function () {
+            return this.instance.anchor.y;
+        },
+        set: function (val) {
+            if (this.instance instanceof pixi_js_1.Sprite)
+                this.instance.anchor.y = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "rotation", {
+        /** rotation is in radians */
+        get: function () {
+            return this.instance.rotation;
+        },
+        /** rotation is in radians */
+        set: function (val) {
+            this.instance.rotation = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "angle", {
+        /** angle is in degrees. */
+        get: function () {
+            return this.instance.angle;
+        },
+        /** angle is in degrees. */
+        set: function (val) {
+            this.instance.angle = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "color", {
+        get: function () {
+            return this.instance.tint;
+        },
+        set: function (val) {
+            if (this.instance instanceof pixi_js_1.Sprite)
+                this.instance.tint = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "opacity", {
+        get: function () {
+            return this.instance.alpha;
+        },
+        set: function (val) {
+            this.instance.alpha = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "active", {
+        get: function () {
+            return this.instance.visible && !this.instance.destroyed;
+        },
+        set: function (val) {
+            this.instance.visible = 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.width = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NodeComp.prototype, "height", {
+        get: function () {
+            return this.instance.height;
+        },
+        set: function (val) {
+            this.instance.height = val;
+        },
+        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.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.convertToNodeSpace = function (point) {
+        return this.instance.toLocal(point);
+    };
+    NodeComp.prototype.convertToNodeSpaceAR = function (point) {
+        return this.instance.toLocal(point);
+    };
+    NodeComp.prototype.convertToWorldSpaceAR = function (point) {
+        return this.instance.toGlobal(point);
+    };
+    NodeComp.prototype.getPosition = function () {
+        return this.instance.position;
+    };
+    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.rotation = deg;
+    };
+    NodeComp.prototype.getRotation = function () {
+        return this.instance.rotation;
+    };
+    // setAnchorPoint(point: number | cc.Point, y?: number) {
+    //   this.instance.setAnchorPoint(point, y)
+    // }
+    // getAnchorPoint() {
+    //   return this.instance.getAnchorPoint()
+    // }
+    // getBoundingBox() {
+    //   const 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;
+    };
+    // setContentSize(size: cc.Size | number, height?: number) {
+    //   this.instance.setContentSize(size, height)
+    //   if (this.instance instanceof cc.ClippingNode) {
+    //     const hw = ((size as any).width || size) * 0.5
+    //     const hh = ((size as any).height || height) * 0.5
+    //     const stencil = new cc.DrawNode()
+    //     const 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.tint = color;
+    };
+    NodeComp.prototype.setScale = function (scaleX, scaleY) {
+        this.instance.scale.x = scaleX;
+        this.instance.scale.x = scaleY || scaleX;
+    };
+    NodeComp.prototype.runAction = function (act) {
+        var animation = pixi_action_ease_1.actionManager.runAction(this.instance, act);
+        this.actionsList.push(animation);
+    };
+    NodeComp.prototype.stopAllActions = function () {
+        this.actionsList.forEach(function (act) {
+            pixi_action_ease_1.actionManager.cancelAction(act);
+        });
+        this.actionsList = [];
+    };
+    NodeComp.prototype.pauseAllActions = function () {
+        this.actionsList.forEach(function (anim) {
+            anim.isPause = true;
+        });
+    };
+    NodeComp.prototype.resumeAllActions = function () {
+        this.actionsList.forEach(function (anim) {
+            anim.isPause = false;
+        });
+    };
+    NodeComp.prototype.destroy = function () {
+        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;
+            });
+        }
+        this.children.forEach(function (child) {
+            child.destroy();
+        });
+        this.parent = null;
+        this.entity.destroy();
+        this.stopAllActions();
+        this.instance.destroy();
+    };
+    NodeComp.prototype.removeFromParent = function () {
+        this.active = false;
+        this.stopAllActions();
+        this.instance.removeFromParent();
+    };
+    NodeComp.prototype.addChild = function (child, zOrder) {
+        child.parent = this;
+        child.active = true;
+        this.children.push(child);
+        this.instance.addChild(child.instance);
+        if (zOrder)
+            child.zIndex = zOrder;
+    };
+    NodeComp.prototype.destroyAllChildren = function () {
+        this.children.forEach(function (child) {
+            child.destroy();
+        });
+    };
+    NodeComp.prototype.on = function (name, callback, target) {
+        var bound = target ? callback.bind(target) : callback;
+        if (this.events[name]) {
+            this.events[name].push(bound);
+        }
+        else {
+            this.events[name] = [bound];
+        }
+    };
+    NodeComp.prototype.off = function (name) {
+        this.events[name] = undefined;
+    };
+    NodeComp.prototype.emit = function (name) {
+        var params = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            params[_i - 1] = arguments[_i];
+        }
+        if (this.events[name]) {
+            this.events[name].forEach(function (fc) { return fc.apply(void 0, params); });
+        }
+    };
+    NodeComp.prototype.resolveComponent = function (component) {
+        if (component.constructor.hasRender) {
+            this.addChild(component.node);
+        }
+        else {
+            this.addComponent(component);
+            if (component instanceof GUIComponent_1.ProgressBarComp) {
+                this.addChild(component.node);
+            }
+        }
+    };
+    NodeComp.prototype.getData = function (key) {
+        return this.data[key];
+    };
+    NodeComp.prototype.setData = function (key, val) {
+        this.data[key] = val;
+    };
+    return NodeComp;
+}());
+exports.NodeComp = NodeComp;

package/dist/components/RenderComponent.d.ts

@@ -0,0 +1,29 @@
+import { ColorSource, Point, TextureSource } from 'pixi.js';
+import { ComponentX } from '../core/decorator';
+import { LoadingBar, LoadingBarMode } from '../core/LoadingBar';
+import { SpriteTypes } from '../systems/RenderSystem';
+export declare class NodeRender extends ComponentX {
+    nodeName?: string;
+}
+export declare class SpriteRender extends ComponentX {
+    spriteFrame: TextureSource;
+    type: SpriteTypes;
+    fillType: LoadingBarMode;
+    fillRange: number;
+    fillCenter: Point;
+    loadingBar: LoadingBar;
+    setFillRange(val: number): void;
+    getSpriteFrame(): TextureSource<any>;
+    setSpriteFrame(frame: any): void;
+}
+export declare class GraphicsRender extends ComponentX {
+    lineWidth: number;
+    strokeColor: ColorSource;
+    fillColor: ColorSource;
+}
+export declare class MaskRender extends ComponentX {
+    type: number;
+    segments: number;
+    inverted: boolean;
+}
+//# sourceMappingURL=RenderComponent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RenderComponent.d.ts","sourceRoot":"","sources":["../../src/components/RenderComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,EAAmB,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5E,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAErD,qBAAa,UAAW,SAAQ,UAAU;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,qBAAa,YAAa,SAAQ,UAAU;IACnC,WAAW,EAAE,aAAa,CAAA;IAC1B,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,EAAE,cAAc,CAAqB;IAC7C,SAAS,SAAI;IACb,UAAU,EAAE,KAAK,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IAQtB,YAAY,CAAC,GAAG,EAAE,MAAM;IAMxB,cAAc;IAId,cAAc,CAAC,KAAK,KAAA;CAkBrB;AAED,qBAAa,cAAe,SAAQ,UAAU;IAC5C,SAAS,SAAI;IACb,WAAW,EAAE,WAAW,CAAA;IACxB,SAAS,EAAE,WAAW,CAAA;CACvB;AAED,qBAAa,UAAW,SAAQ,UAAU;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB"}

package/dist/components/RenderComponent.js

@@ -0,0 +1,89 @@
+"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.MaskRender = exports.GraphicsRender = exports.SpriteRender = exports.NodeRender = void 0;
+var pixi_js_1 = require("pixi.js");
+var decorator_1 = require("../core/decorator");
+var LoadingBar_1 = require("../core/LoadingBar");
+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() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.fillType = LoadingBar_1.LoadingBarMode.BAR;
+        _this.fillRange = 1;
+        return _this;
+    }
+    // set fillStart(val: number) {
+    //   if (this.node.instance instanceof cc.ProgressTimer) {
+    //     this.node.instance.setMidpoint(cc.v2(val, val));
+    //   }
+    // }
+    SpriteRender.prototype.setFillRange = function (val) {
+        if (this.loadingBar) {
+            this.loadingBar.progress = val;
+        }
+    };
+    SpriteRender.prototype.getSpriteFrame = function () {
+        return this.spriteFrame;
+    };
+    SpriteRender.prototype.setSpriteFrame = function (frame) {
+        this.spriteFrame = frame;
+        var sprite = this.node.instance;
+        // if (this.node.instance instanceof cc.Sprite) {
+        sprite.texture = pixi_js_1.Texture.from(frame);
+        // sprite.texture.rotate = 8
+        // } 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);
+        // }
+    };
+    return SpriteRender;
+}(decorator_1.ComponentX));
+exports.SpriteRender = SpriteRender;
+var GraphicsRender = /** @class */ (function (_super) {
+    __extends(GraphicsRender, _super);
+    function GraphicsRender() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.lineWidth = 2;
+        return _this;
+    }
+    return GraphicsRender;
+}(decorator_1.ComponentX));
+exports.GraphicsRender = GraphicsRender;
+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;

package/dist/core/Color.d.ts

@@ -0,0 +1,7 @@
+export declare function Color4B(r: number, g: number, b: number, a: number): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+//# sourceMappingURL=Color.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Color.d.ts","sourceRoot":"","sources":["../../src/core/Color.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;;;;;EAEjE"}

package/dist/core/Color.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color4B = Color4B;
+function Color4B(r, g, b, a) {
+    return ({ r: r, g: g, b: b, a: a });
+}

package/dist/core/LoadingBar.d.ts

@@ -0,0 +1,13 @@
+import { Graphics, Point, Sprite } from 'pixi.js';
+export declare enum LoadingBarMode {
+    BAR = 0,
+    RADIAL = 1
+}
+export declare class LoadingBar extends Graphics {
+    spriteComp: Sprite;
+    mode: LoadingBarMode;
+    fillCenter: Point;
+    constructor(mode: LoadingBarMode, spriteComp: Sprite);
+    set progress(val: number);
+}
+//# sourceMappingURL=LoadingBar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LoadingBar.d.ts","sourceRoot":"","sources":["../../src/core/LoadingBar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAEjD,oBAAY,cAAc;IACxB,GAAG,IAAA;IACH,MAAM,IAAA;CACP;AAED,qBAAa,UAAW,SAAQ,QAAQ;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,cAAc,CAAA;IACpB,UAAU,QAAsB;gBACpB,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM;IAUpD,IAAI,QAAQ,CAAC,GAAG,EAAE,MAAM,EAUvB;CACF"}

package/dist/core/LoadingBar.js

@@ -0,0 +1,55 @@
+"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.LoadingBar = exports.LoadingBarMode = void 0;
+var pixi_js_1 = require("pixi.js");
+var LoadingBarMode;
+(function (LoadingBarMode) {
+    LoadingBarMode[LoadingBarMode["BAR"] = 0] = "BAR";
+    LoadingBarMode[LoadingBarMode["RADIAL"] = 1] = "RADIAL";
+})(LoadingBarMode || (exports.LoadingBarMode = LoadingBarMode = {}));
+var LoadingBar = /** @class */ (function (_super) {
+    __extends(LoadingBar, _super);
+    function LoadingBar(mode, spriteComp) {
+        var _this = _super.call(this) || this;
+        _this.fillCenter = new pixi_js_1.Point(0.5, 0.5);
+        _this.spriteComp = spriteComp;
+        _this.mode = mode || LoadingBarMode.BAR;
+        _this.beginFill(0xffffff);
+        _this.drawRect(0, 0, spriteComp.width, spriteComp.height);
+        spriteComp.mask = _this;
+        spriteComp.addChild(_this);
+        return _this;
+    }
+    Object.defineProperty(LoadingBar.prototype, "progress", {
+        set: function (val) {
+            this.clear();
+            this.beginFill(0xffffff);
+            if (this.mode === LoadingBarMode.BAR) {
+                var spriteComp = this.spriteComp;
+                this.drawRect(0, 0, spriteComp.width * val, spriteComp.height);
+                // console.log('new length', spriteComp.width)
+                this.x = -spriteComp.width * 0.5;
+                this.y = -spriteComp.height * 0.5;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return LoadingBar;
+}(pixi_js_1.Graphics));
+exports.LoadingBar = LoadingBar;

package/dist/core/Scene.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedComponent } from '../components/EnhancedComponent';
+export declare class SceneComponent extends EnhancedComponent {
+    static boot: () => void;
+    static create(): SceneComponent;
+}
+//# sourceMappingURL=Scene.d.ts.map

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

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

package/dist/core/Scene.js

@@ -0,0 +1,39 @@
+"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 app_1 = require("../app");
+var EnhancedComponent_1 = require("../components/EnhancedComponent");
+var NodeComp_1 = require("../components/NodeComp");
+var gworld_1 = require("../gworld");
+var SceneComponent = /** @class */ (function (_super) {
+    __extends(SceneComponent, _super);
+    function SceneComponent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SceneComponent.create = function () {
+        var world = gworld_1.GameWorld.Instance;
+        world.entities.reset();
+        var root = world.entities.create();
+        var node = root.assign(new NodeComp_1.NodeComp(app_1.app.stage, root));
+        var sceneComponent = root.assign(new SceneComponent());
+        sceneComponent.node = node;
+        return sceneComponent;
+    };
+    return SceneComponent;
+}(EnhancedComponent_1.EnhancedComponent));
+exports.SceneComponent = SceneComponent;