@safe-engine/pixi 8.1.4 → 8.2.2

package/dist/norender/NoRenderComponent.js

@@ -0,0 +1,53 @@
+import { FederatedPointerEvent } from 'pixi.js';
+import { NoRenderComponentX } from '../components/BaseComponent';
+export class Touch extends FederatedPointerEvent {
+}
+export class EventRegister extends NoRenderComponentX {
+    constructor() {
+        super(...arguments);
+        this.events = {};
+    }
+    on(name, callback, target) {
+        const bound = target ? callback.bind(target) : callback;
+        if (this.events[name]) {
+            this.events[name].push(bound);
+        }
+        else {
+            this.events[name] = [bound];
+        }
+    }
+    off(name) {
+        this.events[name] = undefined;
+    }
+    emit(name, ...params) {
+        if (this.events[name]) {
+            this.events[name].forEach((fc) => fc(...params));
+        }
+    }
+}
+export class TouchEventRegister extends NoRenderComponentX {
+    setOnTouchStart(cb) {
+        this.onTouchStart = cb;
+    }
+    setOnTouchMove(cb) {
+        this.onTouchMove = cb;
+    }
+    setOnTouchEnd(cb) {
+        this.onTouchEnd = cb;
+    }
+    setOnTouchCancel(cb) {
+        this.onTouchCancel = cb;
+    }
+}
+export class ExtraDataComp extends NoRenderComponentX {
+    constructor() {
+        super(...arguments);
+        this.data = {};
+    }
+    getData(key) {
+        return this.data[key];
+    }
+    setData(key, val) {
+        this.data[key] = val;
+    }
+}

package/dist/norender/NoRenderSystem.d.ts

@@ -0,0 +1,5 @@
+import { EventManager, System } from 'entityx-ts';
+export declare class NoRenderSystem implements System {
+    configure(event_manager: EventManager): void;
+}
+//# sourceMappingURL=NoRenderSystem.d.ts.map

package/dist/norender/NoRenderSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoRenderSystem.d.ts","sourceRoot":"","sources":["../../src/norender/NoRenderSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAc,MAAM,EAAE,MAAM,YAAY,CAAA;AAO7D,qBAAa,cAAe,YAAW,MAAM;IAC3C,SAAS,CAAC,aAAa,EAAE,YAAY;CAyDtC"}

package/dist/norender/NoRenderSystem.js

@@ -0,0 +1,57 @@
+import { EventTypes } from 'entityx-ts';
+import { NodeComp } from '../components/NodeComp';
+import { ExtraDataComp, TouchEventRegister } from './NoRenderComponent';
+export class NoRenderSystem {
+    configure(event_manager) {
+        event_manager.subscribe(EventTypes.ComponentAdded, ExtraDataComp, ({ entity, component }) => {
+            const { key, value } = component;
+            component.data[key] = value;
+        });
+        event_manager.subscribe(EventTypes.ComponentAdded, TouchEventRegister, ({ entity, component }) => {
+            const ett = entity;
+            const touchComp = component;
+            const nodeComp = ett.getComponent(NodeComp);
+            touchComp.node = nodeComp;
+            const container = nodeComp.instance;
+            if (touchComp.onTouchStart) {
+                container.on('touchstart', (event) => {
+                    touchComp.onTouchStart(event, nodeComp);
+                });
+            }
+            if (touchComp.onTouchMove) {
+                container.on('touchmove', (event) => {
+                    touchComp.onTouchMove(event, nodeComp);
+                });
+            }
+            if (touchComp.onTouchEnd) {
+                container.on('touchend', (event) => {
+                    touchComp.onTouchEnd(event, nodeComp);
+                });
+            }
+            if (touchComp.onTouchEnd) {
+                container.on('touchcancel', (event) => {
+                    touchComp.onTouchEnd(event, nodeComp);
+                });
+            }
+        });
+        event_manager.subscribe(EventTypes.ComponentRemoved, TouchEventRegister, ({ entity, component }) => {
+            console.log('ComponentRemovedEvent TouchEventRegister', event);
+            // const ett = event.entity
+            // const nodeComp = ett.getComponent(NodeComp)
+            const touchComp = component;
+            const container = touchComp.node.instance;
+            if (touchComp.onTouchStart) {
+                container.removeListener('touchstart');
+            }
+            if (touchComp.onTouchMove) {
+                container.removeListener('touchmove');
+            }
+            if (touchComp.onTouchEnd) {
+                container.removeListener('touchend');
+            }
+            if (touchComp.onTouchEnd) {
+                container.removeListener('touchcancel');
+            }
+        });
+    }
+}

package/dist/planck/PhysicsComponent.d.ts

@@ -0,0 +1,37 @@
+import { Body, BodyType, Vec2 } from 'planck';
+import { BoxColliderPhysicsProps, CircleColliderPhysicsProps, ColliderPhysicsProps, PhysicsMaterialProps, PolygonColliderPhysicsProps, RigidBodyProps } from '../../@types/safex';
+import { NoRenderComponentX } from '../components/BaseComponent';
+import { PhysicsSprite } from './PhysicsSprite';
+export declare class RigidBody extends NoRenderComponentX<RigidBodyProps> {
+    type: BodyType;
+    density: number;
+    restitution: number;
+    friction: number;
+    body: Body;
+    gravityScale: number;
+}
+export declare class PhysicsMaterial extends NoRenderComponentX<PhysicsMaterialProps> {
+    density: number;
+    restitution: number;
+    friction: number;
+}
+export declare class ColliderPhysics<T extends ColliderPhysicsProps = ColliderPhysicsProps> extends NoRenderComponentX<T, PhysicsSprite['node']> {
+    tag: number;
+    group: number;
+    offset: Vec2;
+    onCollisionEnter: (other: ColliderPhysics) => void;
+    onCollisionExit: (other: ColliderPhysics) => void;
+    enabled: boolean;
+    instance: PhysicsSprite;
+}
+export declare class BoxColliderPhysics extends ColliderPhysics<BoxColliderPhysicsProps> {
+    width: number;
+    height: number;
+}
+export declare class CircleColliderPhysics extends ColliderPhysics<CircleColliderPhysicsProps> {
+    radius: number;
+}
+export declare class PolygonColliderPhysics extends ColliderPhysics<PolygonColliderPhysicsProps> {
+    points: number[];
+}
+//# sourceMappingURL=PhysicsComponent.d.ts.map

package/dist/planck/PhysicsComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsComponent.d.ts","sourceRoot":"","sources":["../../src/planck/PhysicsComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7C,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACjL,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAG/C,qBAAa,SAAU,SAAQ,kBAAkB,CAAC,cAAc,CAAC;IAC/D,IAAI,EAAE,QAAQ,CAAY;IAC1B,OAAO,SAAI;IACX,WAAW,SAAM;IACjB,QAAQ,SAAM;IACd,IAAI,EAAE,IAAI,CAAA;IACV,YAAY,SAAI;CAmBjB;AAED,qBAAa,eAAgB,SAAQ,kBAAkB,CAAC,oBAAoB,CAAC;IAC3E,OAAO,SAAI;IACX,WAAW,SAAI;IACf,QAAQ,SAAI;CACb;AAED,qBAAa,eAAe,CAAC,CAAC,SAAS,oBAAoB,GAAG,oBAAoB,CAAE,SAAQ,kBAAkB,CAAC,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtI,GAAG,SAAI;IACP,KAAK,SAAI;IACT,MAAM,EAAE,IAAI,CAAc;IAC1B,gBAAgB,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;IAClD,eAAe,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;IACjD,OAAO,UAAO;IACd,QAAQ,EAAE,aAAa,CAAA;CACxB;AAED,qBAAa,kBAAmB,SAAQ,eAAe,CAAC,uBAAuB,CAAC;IAC9E,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CAWf;AAED,qBAAa,qBAAsB,SAAQ,eAAe,CAAC,0BAA0B,CAAC;IACpF,MAAM,EAAE,MAAM,CAAA;CACf;AAED,qBAAa,sBAAuB,SAAQ,eAAe,CAAC,2BAA2B,CAAC;IACtF,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB"}

package/dist/planck/PhysicsComponent.js

@@ -0,0 +1,52 @@
+import { Vec2 } from 'planck';
+import { NoRenderComponentX } from '../components/BaseComponent';
+export class RigidBody extends NoRenderComponentX {
+    constructor() {
+        super(...arguments);
+        this.type = 'dynamic';
+        this.density = 1;
+        this.restitution = 0.5;
+        this.friction = 0.3;
+        this.gravityScale = 1;
+        // set linearVelocity(vel: Vec2) {
+        //   if (!this.node) {
+        //     return
+        //   }
+        //   const physics = this.node.instance
+        //   if (physics instanceof Sprite) {
+        //     physics.getBody().setVel(vel)
+        //   }
+        // }
+        // get linearVelocity() {
+        //   if (!this.node) {
+        //     return Vec2.ZERO
+        //   }
+        //   const physics = this.node.instance
+        //   const vel = (physics as Sprite).getBody().getVel()
+        //   return v2(vel)
+        // }
+    }
+}
+export class PhysicsMaterial extends NoRenderComponentX {
+    constructor() {
+        super(...arguments);
+        this.density = 1;
+        this.restitution = 0;
+        this.friction = 0;
+    }
+}
+export class ColliderPhysics extends NoRenderComponentX {
+    constructor() {
+        super(...arguments);
+        this.tag = 0;
+        this.group = 0;
+        this.offset = Vec2.zero();
+        this.enabled = true;
+    }
+}
+export class BoxColliderPhysics extends ColliderPhysics {
+}
+export class CircleColliderPhysics extends ColliderPhysics {
+}
+export class PolygonColliderPhysics extends ColliderPhysics {
+}

package/dist/planck/PhysicsSprite.d.ts

@@ -0,0 +1,16 @@
+import { Container } from 'pixi.js';
+import { Body, Vec2 } from 'planck';
+export declare class PhysicsSprite {
+    node: Container;
+    physicsBody: Body;
+    constructor(node: Container, body: Body);
+    set position(val: Vec2);
+    set x(val: number);
+    set y(val: number);
+    get x(): number;
+    get y(): number;
+    set angle(val: number);
+    get angle(): number;
+    addChild(child: Container): void;
+}
+//# sourceMappingURL=PhysicsSprite.d.ts.map

package/dist/planck/PhysicsSprite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsSprite.d.ts","sourceRoot":"","sources":["../../src/planck/PhysicsSprite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAEnC,qBAAa,aAAa;IACxB,IAAI,EAAE,SAAS,CAAA;IACf,WAAW,EAAE,IAAI,CAAA;gBAEL,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI;IAKvC,IAAI,QAAQ,CAAC,GAAG,EAAE,IAAI,EAErB;IAED,IAAI,CAAC,CAAC,GAAG,QAAA,EAER;IACD,IAAI,CAAC,CAAC,GAAG,QAAA,EAER;IAED,IAAI,CAAC,WAEJ;IAED,IAAI,CAAC,WAEJ;IAED,IAAI,KAAK,CAAC,GAAG,EAAE,MAAM,EAEpB;IAED,IAAI,KAAK,IAJM,MAAM,CAMpB;IAED,QAAQ,CAAC,KAAK,EAAE,SAAS;CAG1B"}

package/dist/planck/PhysicsSprite.js

@@ -0,0 +1,31 @@
+import { Vec2 } from 'planck';
+export class PhysicsSprite {
+    constructor(node, body) {
+        this.node = node;
+        this.physicsBody = body;
+    }
+    set position(val) {
+        this.physicsBody.setPosition(val);
+    }
+    set x(val) {
+        this.physicsBody.setPosition(Vec2(val, this.y));
+    }
+    set y(val) {
+        this.physicsBody.setPosition(Vec2(this.x, val));
+    }
+    get x() {
+        return this.physicsBody.getPosition().x;
+    }
+    get y() {
+        return this.physicsBody.getPosition().x;
+    }
+    set angle(val) {
+        this.physicsBody.setAngle(val);
+    }
+    get angle() {
+        return this.physicsBody.getAngle();
+    }
+    addChild(child) {
+        this.node.addChild(child);
+    }
+}

package/dist/planck/PhysicsSystem.d.ts

@@ -0,0 +1,20 @@
+import { EntityManager, EventManager, System } from 'entityx-ts';
+import { Body, Contact, Fixture, Manifold, Shape, World } from 'planck';
+export declare function setColliderMatrix(colliderMatrix?: boolean[][]): void;
+export declare class PhysicsSystem implements System {
+    world: World;
+    listRemoveBody: Body[];
+    listRemoveShape: Shape[];
+    colliderMatrix: boolean[][];
+    configure(event_manager: EventManager): void;
+    update(entities: EntityManager, events: EventManager, dt: number): void;
+    renderBody(body: Body): void;
+    renderFixture(fixture: Fixture): void;
+    renderJoint(joint: any): void;
+    contactBegin(contact: Contact): void;
+    preSolve(contact: Contact, oldManifold: Manifold): void;
+    postSolve(contact: Contact, contactImpulse: any): void;
+    contactEnd(contact: Contact): void;
+    set enabled(val: any);
+}
+//# sourceMappingURL=PhysicsSystem.d.ts.map

package/dist/planck/PhysicsSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../src/planck/PhysicsSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EACb,YAAY,EAEZ,MAAM,EACP,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,IAAI,EAAO,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAQ,KAAK,EAAE,MAAM,QAAQ,CAAA;AAqBlF,wBAAgB,iBAAiB,CAAC,cAAc,cAAW,QAG1D;AAED,qBAAa,aAAc,YAAW,MAAM;IAC1C,KAAK,EAAE,KAAK,CAAA;IACZ,cAAc,EAAE,IAAI,EAAE,CAAK;IAC3B,eAAe,EAAE,KAAK,EAAE,CAAK;IAC7B,cAAc,cAAW;IAEzB,SAAS,CAAC,aAAa,EAAE,YAAY;IAgErC,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM;IAoBhE,UAAU,CAAC,IAAI,EAAE,IAAI;IAWrB,aAAa,CAAC,OAAO,EAAE,OAAO;IAM9B,WAAW,CAAC,KAAK,KAAA;IAIjB,YAAY,CAAC,OAAO,EAAE,OAAO;IAsB7B,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ;IAIhD,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,KAAA;IAI1C,UAAU,CAAC,OAAO,EAAE,OAAO;IAkB3B,IAAI,OAAO,CAAC,GAAG,KAAA,EAMd;CACF"}

package/dist/planck/PhysicsSystem.js

@@ -0,0 +1,187 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { EventTypes } from 'entityx-ts';
+import { Box, Fixture, Vec2, World } from 'planck';
+import { Graphics } from 'pixi.js';
+import { GameWorld, instantiate } from '../base';
+import { NodeComp } from '../components/NodeComp';
+import { BoxColliderPhysics, CircleColliderPhysics, ColliderPhysics, PolygonColliderPhysics, RigidBody, } from './PhysicsComponent';
+import { PhysicsSprite } from './PhysicsSprite';
+Fixture.prototype.shouldCollide = function (other) {
+    const nodeThis = this.getBody().getUserData();
+    const nodeOther = other.getBody().getUserData();
+    const { colliderMatrix } = GameWorld.Instance.systems.get(PhysicsSystem);
+    return colliderMatrix[nodeOther.group][nodeThis.group];
+};
+export function setColliderMatrix(colliderMatrix = [[true]]) {
+    const physicsSystem = GameWorld.Instance.systems.get(PhysicsSystem);
+    physicsSystem.colliderMatrix = colliderMatrix;
+}
+export class PhysicsSystem {
+    constructor() {
+        this.listRemoveBody = [];
+        this.listRemoveShape = [];
+        this.colliderMatrix = [[true]];
+    }
+    configure(event_manager) {
+        // Settings.lengthUnitsPerMeter = 100
+        this.world = new World({
+            gravity: Vec2(0, -10.0),
+        });
+        // event_manager.world.physicsManager = this
+        // event_manager.subscribe(ComponentAddedEvent(RigidBody), this);
+        event_manager.subscribe(EventTypes.ComponentAdded, BoxColliderPhysics, ({ entity, component }) => {
+            console.log('ComponentAddedEvent BoxColliderPhysics', component);
+            let rigidBody = entity.getComponent(RigidBody);
+            if (!rigidBody) {
+                rigidBody = instantiate(RigidBody);
+                entity.assign(rigidBody);
+            }
+            // const physicsMaterial = entity.getComponent(PhysicsMaterial)
+            const box = component;
+            const node = entity.getComponent(NodeComp);
+            const { width, height } = box, colliderProps = __rest(box
+            // ett.assign(instantiate(ColliderPhysics, { tag, offset }))
+            // const { density, restitution, friction } = physicsMaterial
+            , ["width", "height"]);
+            // ett.assign(instantiate(ColliderPhysics, { tag, offset }))
+            // const { density, restitution, friction } = physicsMaterial
+            const body = this.world.createBody({
+                position: node.position, // the body's origin position.
+                angle: 0.25 * Math.PI, // the body's angle in radians.
+                userData: node,
+                type: rigidBody.type,
+                gravityScale: rigidBody.gravityScale,
+            });
+            rigidBody.body = body;
+            // console.log('body', body);
+            // body.setMassData({ mass: 1 } as any)
+            const physicsNode = new PhysicsSprite(node.instance, body);
+            const shape = new Box(width, height);
+            body.createFixture({
+                shape,
+                density: 1,
+                isSensor: true,
+            });
+            const debugBox = new Graphics();
+            const { x, y } = colliderProps.offset;
+            debugBox.rect(x, y, width, height);
+            debugBox.fill({ color: 0xff0000, alpha: 0.3 });
+            node.instance.addChild(debugBox);
+            const physicsCollide = entity.assign(instantiate(ColliderPhysics, colliderProps));
+            physicsCollide.instance = physicsNode;
+            physicsCollide.node = node;
+            box.node = node;
+        });
+        event_manager.subscribe(EventTypes.ComponentAdded, (CircleColliderPhysics), () => { });
+        event_manager.subscribe(EventTypes.ComponentAdded, (PolygonColliderPhysics), () => { });
+        event_manager.subscribe(EventTypes.ComponentRemoved, (NodeComp), () => {
+            // log('ComponentRemovedEvent NodeComp', event);
+            // const node = event.entity.getComponent(NodeComp)
+            // if (node.instance instanceof Sprite) {
+            //   const body = node.instance.getBody()
+            //   this.listRemoveShape.push(...body.shapeList)
+            //   this.listRemoveBody.push(body)
+            // }
+        });
+        this.world.on('begin-contact', this.contactBegin.bind(this));
+        this.world.on('end-contact', this.contactEnd.bind(this));
+        this.world.on('pre-solve', this.preSolve.bind(this));
+        this.world.on('post-solve', this.postSolve.bind(this));
+    }
+    update(entities, events, dt) {
+        if (this.world) {
+            this.world.step(dt);
+            // Iterate over bodies
+            for (let body = this.world.getBodyList(); body; body = body.getNext()) {
+                this.renderBody(body);
+                // ... and fixtures
+                for (let fixture = body.getFixtureList(); fixture; fixture = fixture.getNext()) {
+                    this.renderFixture(fixture);
+                }
+            }
+            // Iterate over joints
+            for (let joint = this.world.getJointList(); joint; joint = joint.getNext()) {
+                this.renderJoint(joint);
+            }
+        }
+    }
+    renderBody(body) {
+        // Render or update body rendering
+        const ett = body.getUserData();
+        const collider = ett.getComponent(ColliderPhysics);
+        if (collider) {
+            collider.instance.node.position = body.getPosition();
+            collider.instance.angle = body.getAngle();
+            // console.log('renderBody body', body.getPosition())
+        }
+    }
+    renderFixture(fixture) {
+        // Render or update fixture rendering
+        // const shape = fixture.getShape()
+        // console.log('renderFixture shape', shape.m_type)
+    }
+    renderJoint(joint) {
+        // Render or update joint rendering
+    }
+    contactBegin(contact) {
+        const ett1 = contact.getFixtureA().getBody().getUserData();
+        const ett2 = contact.getFixtureB().getBody().getUserData();
+        // this.world.addPostStepCallback(() => {
+        //   // log('addPostStepCallback');
+        //   this.listRemoveShape.forEach((s) => this.world.removeShape(s))
+        //   this.listRemoveBody.forEach((b) => this.world.removeBody(b))
+        //   this.listRemoveBody = []
+        //   this.listRemoveShape = []
+        // })
+        const phys1 = ett1.getComponent(ColliderPhysics);
+        const phys2 = ett2.getComponent(ColliderPhysics);
+        if (phys1 && phys2) {
+            if (Object.prototype.hasOwnProperty.call(phys1, 'onCollisionEnter')) {
+                phys1.onCollisionEnter(phys2);
+            }
+            if (Object.prototype.hasOwnProperty.call(phys2, 'onCollisionEnter')) {
+                phys2.onCollisionEnter(phys1);
+            }
+        }
+    }
+    preSolve(contact, oldManifold) {
+        // log('preSolve');
+    }
+    postSolve(contact, contactImpulse) {
+        // log('collisionPost');
+    }
+    contactEnd(contact) {
+        // log('collisionSeparate');
+        const ett1 = contact.getFixtureA().getBody().getUserData();
+        const ett2 = contact.getFixtureB().getBody().getUserData();
+        // const event1 = ett1.getComponent(NodeComp)
+        const phys1 = ett1.getComponent(ColliderPhysics);
+        const phys2 = ett2.getComponent(ColliderPhysics);
+        // const event2 = ett2.getComponent(NodeComp)
+        if (phys1 && phys2) {
+            if (Object.prototype.hasOwnProperty.call(phys1, 'onCollisionExit')) {
+                phys1.onCollisionExit(phys2);
+            }
+            if (Object.prototype.hasOwnProperty.call(phys2, 'onCollisionExit')) {
+                phys2.onCollisionExit(phys1);
+            }
+        }
+    }
+    set enabled(val) {
+        if (val) {
+            this.world.setGravity(Vec2(0, -1));
+            // this.world.iterations = 60
+            // this.world.collisionSlop = 0.5
+        }
+    }
+}

package/dist/planck/index.d.ts

@@ -0,0 +1,4 @@
+export * from './PhysicsComponent';
+export * from './PhysicsSprite';
+export * from './PhysicsSystem';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/planck/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA"}

package/dist/planck/index.js

@@ -0,0 +1,3 @@
+export * from './PhysicsComponent';
+export * from './PhysicsSprite';
+export * from './PhysicsSystem';

package/dist/render/RenderComponent.d.ts

@@ -0,0 +1,52 @@
+import { Graphics, Point, Sprite } from 'pixi.js';
+import { Color4B, Vec2 } from '..';
+import { GraphicsRenderProps, MaskRenderProps, SpriteRenderProps } from '../../@types/safex';
+import { ComponentX } from '../components/BaseComponent';
+import { LoadingBar, LoadingBarMode } from '../core/LoadingBar';
+import { SpriteTypes } from './RenderSystem';
+export declare class NodeRender extends ComponentX {
+    nodeName?: string;
+}
+export declare class SpriteRender extends ComponentX<SpriteRenderProps, Sprite> {
+    spriteFrame: string;
+    type: SpriteTypes;
+    fillType: LoadingBarMode;
+    fillRange: number;
+    fillCenter: Point;
+    loadingBar: LoadingBar;
+    setFillRange(val: number): void;
+    getSpriteFrame(): string;
+    setSpriteFrame(frame: any): void;
+}
+declare enum PointType {
+    Circle = 0,
+    Rect = 1
+}
+export declare class GraphicsRender extends ComponentX<GraphicsRenderProps, Graphics> {
+    lineWidth: number;
+    strokeColor: Color4B;
+    fillColor: Color4B;
+    drawPoint(position: Vec2, pointSize: Float, color: Color4B, pointType?: PointType): void;
+    drawLine(origin: Vec2, destination: Vec2, color: Color4B, thickness: Float): void;
+    drawRect(origin: Vec2, destination: Vec2, color: Color4B): void;
+    drawSolidRect(origin: Vec2, destination: Vec2, color: Color4B): void;
+    drawCircle(center: Vec2, radius: Float, angle?: Float, segments?: Integer, drawLineToCenter?: boolean, scaleX?: Float, scaleY?: Float, color?: Color4B, thickness?: Float): void;
+    drawSolidCircle(origin: Vec2, destination: Vec2, color: Color4B): void;
+    drawQuadBezier(origin: Vec2, destination: Vec2, color: Color4B): void;
+    drawCubicBezier(origin: Vec2, destination: Vec2, color: Color4B): void;
+    drawCardinalSpline(points: Vec2[], color: Color4B): void;
+    drawCatmullRom(points: Vec2[], color: Color4B): void;
+    drawPoly(points: Vec2[], closedPolygon: boolean, color: Color4B, thickness?: Float): void;
+    drawSolidPoly(points: Vec2[], color: Color4B): void;
+    drawDot(points: Vec2[], color: Color4B): void;
+    drawSegment(from: Vec2, to: Vec2, color: Color4B): void;
+    drawTriangle(p1: Vec2, p2: Vec2, p3: Vec2, color: Color4B): void;
+    clear(): void;
+}
+export declare class MaskRender extends ComponentX<MaskRenderProps> {
+    type: number;
+    segments: number;
+    inverted: boolean;
+}
+export {};
+//# sourceMappingURL=RenderComponent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RenderComponent.d.ts","sourceRoot":"","sources":["../../src/render/RenderComponent.ts"],"names":[],"mappings":"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"}

package/dist/render/RenderComponent.js

@@ -0,0 +1,104 @@
+import { Texture } from 'pixi.js';
+import { ComponentX } from '../components/BaseComponent';
+import { LoadingBarMode } from '../core/LoadingBar';
+export class NodeRender extends ComponentX {
+}
+export class SpriteRender extends ComponentX {
+    constructor() {
+        super(...arguments);
+        this.fillType = LoadingBarMode.BAR;
+        this.fillRange = 1;
+    }
+    // set fillStart(val: number) {
+    //   if (this.node.instance instanceof cc.ProgressTimer) {
+    //     this.node.instance.setMidpoint(cc.v2(val, val));
+    //   }
+    // }
+    setFillRange(val) {
+        if (this.loadingBar) {
+            this.loadingBar.progress = val;
+        }
+    }
+    getSpriteFrame() {
+        return this.spriteFrame;
+    }
+    setSpriteFrame(frame) {
+        this.spriteFrame = frame;
+        const sprite = this.node.instance;
+        // if (this.node.instance instanceof cc.Sprite) {
+        sprite.texture = 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);
+        // }
+    }
+}
+var PointType;
+(function (PointType) {
+    PointType[PointType["Circle"] = 0] = "Circle";
+    PointType[PointType["Rect"] = 1] = "Rect";
+})(PointType || (PointType = {}));
+;
+export class GraphicsRender extends ComponentX {
+    constructor() {
+        super(...arguments);
+        this.lineWidth = 2;
+    }
+    drawPoint(position, pointSize, color, pointType = PointType.Rect) {
+    }
+    // drawPoints(points: Vec2[], color: Color4B) {
+    // }
+    drawLine(origin, destination, color, thickness) {
+    }
+    drawRect(origin, destination, color) {
+        const { x, y } = origin;
+        const width = destination.x - x;
+        const height = destination.y - y;
+        this.node.instance.rect(x, y, width, height);
+        this.node.instance.fill(color);
+    }
+    drawSolidRect(origin, destination, color) {
+    }
+    drawCircle(center, radius, angle, segments, drawLineToCenter, scaleX, scaleY, color, thickness) {
+        const { x, y } = center;
+        this.node.instance.circle(x, y, radius);
+        this.node.instance.fill(color);
+    }
+    drawSolidCircle(origin, destination, color) {
+    }
+    drawQuadBezier(origin, destination, color) {
+    }
+    drawCubicBezier(origin, destination, color) {
+    }
+    drawCardinalSpline(points, color) {
+    }
+    drawCatmullRom(points, color) {
+    }
+    drawPoly(points, closedPolygon, color, thickness) {
+        this.node.instance.poly(points, closedPolygon);
+        this.node.instance.fill(color);
+    }
+    drawSolidPoly(points, color) {
+    }
+    drawDot(points, color) {
+    }
+    drawSegment(from, to, color) {
+    }
+    drawTriangle(p1, p2, p3, color) {
+        this.node.instance.poly([p1, p2, p3], true);
+        this.node.instance.fill(color);
+    }
+    clear() {
+        this.node.instance.clear();
+    }
+}
+export class MaskRender extends ComponentX {
+}

package/dist/render/RenderSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderSystem.d.ts","sourceRoot":"","sources":["../../src/render/RenderSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,MAAM,EACP,MAAM,YAAY,CAAA;AAOnB,oBAAY,WAAW;IACrB,MAAM,IAAA;IACN,MAAM,IAAA;IACN,KAAK,IAAA;IACL,MAAM,IAAA;IACN,IAAI,IAAA;IACJ,SAAS,IAAA;CACV;AAED,qBAAa,YAAa,YAAW,MAAM;IACzC,SAAS,CAAC,aAAa,EAAE,YAAY;CAmDtC"}