@safe-engine/pixi 8.4.1 → 8.4.3

package/src/box2d-wasm/debugDraw.ts

@@ -1,4 +1,6 @@
-import { Color4B, Graphics } from "..";
+import { Graphics } from 'pixi.js'
+
+import { Color4B } from '..'
 
 /**
  * Forked from Box2D.js
@@ -22,16 +24,15 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
     b2Transform,
     b2Vec2,
     JSDraw,
-    wrapPointer
-  } = box2D;
+    wrapPointer,
+  } = box2D
 
   /**
    * to replace original C++ operator =
    * @param {Box2D.b2Vec2} vec
    * @returns {Box2D.b2Vec2}
    */
-  const copyVec2 = (vec: Box2D.b2Vec2) =>
-    new b2Vec2(vec.get_x(), vec.get_y());
+  const copyVec2 = (vec: Box2D.b2Vec2) => new b2Vec2(vec.get_x(), vec.get_y())
 
   /**
    * to replace original C++ operator *= (float)
@@ -39,28 +40,27 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
    * @param {number} scale
    * @returns {Box2D.b2Vec2}
    */
-  const scaledVec2 = (vec: Box2D.b2Vec2, scale: number) =>
-    new b2Vec2(scale * vec.get_x(), scale * vec.get_y());
+  const scaledVec2 = (vec: Box2D.b2Vec2, scale: number) => new b2Vec2(scale * vec.get_x(), scale * vec.get_y())
 
   /**
    * @param {Box2D.b2Color} color
    * @returns {string}
    */
   const getRgbStr = (color: Box2D.b2Color) => {
-    const red = (color.get_r() * 255) | 0;
-    const green = (color.get_g() * 255) | 0;
-    const blue = (color.get_b() * 255) | 0;
-    return Color4B(red, green, blue, 0.1);
-  };
+    const red = (color.get_r() * 255) | 0
+    const green = (color.get_g() * 255) | 0
+    const blue = (color.get_b() * 255) | 0
+    return Color4B(red, green, blue, 0.1)
+  }
 
   /**
    * @param {string} rgbStr
    * @returns {void}
    */
   const setCtxColor = (rgbStr: Color4B) => {
-    graphics.fillStyle = rgbStr;
-    graphics.strokeStyle = { color: rgbStr };
-  };
+    graphics.fillStyle = rgbStr
+    graphics.strokeStyle = { color: rgbStr }
+  }
 
   /**
    * @param {Box2D.b2Vec2[]} vertices
@@ -70,13 +70,12 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
   const drawPolygon = (vertices, fill) => {
     // console.log("drawPolygon", vertices[0].y, fill);
     // graphics.poly(vertices, fill)
-    graphics.moveTo(vertices[vertices.length - 1].x * pixelsPerMeter,
-      vertices[vertices.length - 1].y * pixelsPerMeter);
+    graphics.moveTo(vertices[vertices.length - 1].x * pixelsPerMeter, vertices[vertices.length - 1].y * pixelsPerMeter)
     vertices.forEach((v) => {
-      graphics.lineTo(v.x * pixelsPerMeter, v.y * pixelsPerMeter);
+      graphics.lineTo(v.x * pixelsPerMeter, v.y * pixelsPerMeter)
     })
     graphics.fill()
-  };
+  }
 
   /**
    * @param {Box2D.b2Vec2} center
@@ -87,22 +86,22 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
    */
   const drawCircle = (center, radius, axis, fill) => {
     // graphics.circle(center.x, center.y, radius)
-    let angle = 0;
-    const angleStep = 32;
-    const n = 360 / angleStep;
-    let x = radius * Math.cos(angle * Math.PI / 180);
-    let y = radius * Math.sin(angle * Math.PI / 180);
-    graphics.moveTo(center.x + x, center.y + y);
-    angle += angleStep;
+    let angle = 0
+    const angleStep = 32
+    const n = 360 / angleStep
+    let x = radius * Math.cos((angle * Math.PI) / 180)
+    let y = radius * Math.sin((angle * Math.PI) / 180)
+    graphics.moveTo(center.x + x, center.y + y)
+    angle += angleStep
 
     for (let i = 0; i < n; i++) {
-      x = radius * Math.cos(angle * Math.PI / 180);
-      y = radius * Math.sin(angle * Math.PI / 180);
-      graphics.lineTo(center.x + x, center.y + y);
-      angle += angleStep;
+      x = radius * Math.cos((angle * Math.PI) / 180)
+      y = radius * Math.sin((angle * Math.PI) / 180)
+      graphics.lineTo(center.x + x, center.y + y)
+      angle += angleStep
     }
     graphics.fill()
-  };
+  }
 
   /**
    * @param {Box2D.b2Vec2} vert1
@@ -111,10 +110,10 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
    */
   const drawSegment = (vert1, vert2) => {
     // console.log("drawSegment", vert1, vert2)
-    graphics.moveTo(vert1.get_x(), vert1.get_y());
-    graphics.lineTo(vert2.get_x(), vert2.get_y());
-    graphics.stroke();
-  };
+    graphics.moveTo(vert1.get_x(), vert1.get_y())
+    graphics.lineTo(vert2.get_x(), vert2.get_y())
+    graphics.stroke()
+  }
 
   /**
    * @param {Box2D.b2Vec2} vertex
@@ -122,14 +121,9 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
    * @returns {void}
    */
   const drawPoint = (vertex, sizeMetres) => {
-    const sizePixels = sizeMetres / pixelsPerMeter;
-    graphics.rect(
-      vertex.get_x() - sizePixels / 2,
-      vertex.get_y() - sizePixels / 2,
-      sizePixels,
-      sizePixels
-    );
-  };
+    const sizePixels = sizeMetres / pixelsPerMeter
+    graphics.rect(vertex.get_x() - sizePixels / 2, vertex.get_y() - sizePixels / 2, sizePixels, sizePixels)
+  }
 
   /**
    * @param {Box2D.b2Transform} transform
@@ -137,19 +131,19 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
    * @returns {void}
    */
   const drawTransform = (transform: Box2D.b2Transform) => {
-    const pos = transform.get_p();
-    const rot = transform.get_q();
+    const pos = transform.get_p()
+    const rot = transform.get_q()
 
-    graphics.save();
-    graphics.translateTransform(pos.get_x(), pos.get_y());
-    graphics.scaleTransform(0.5, 0.5);
-    graphics.rotateTransform(rot.GetAngle());
+    graphics.save()
+    graphics.translateTransform(pos.get_x(), pos.get_y())
+    graphics.scaleTransform(0.5, 0.5)
+    graphics.rotateTransform(rot.GetAngle())
     // graphics.lineWidth *= 2;
-    graphics.restore();
+    graphics.restore()
   }
 
   /** {@link Box2D.b2Vec2} is a struct of `float x, y` */
-  const sizeOfB2Vec = Float32Array.BYTES_PER_ELEMENT * 2;
+  const sizeOfB2Vec = Float32Array.BYTES_PER_ELEMENT * 2
 
   /**
    * @param {number} array_p pointer to {@link Box2D.b2Vec2}
@@ -161,9 +155,7 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
   const reifyArray = (array_p, numElements, sizeOfElement, ctor) =>
     Array(numElements)
       .fill(undefined)
-      .map((_, index) =>
-        wrapPointer(array_p + index * sizeOfElement, ctor)
-      );
+      .map((_, index) => wrapPointer(array_p + index * sizeOfElement, ctor))
 
   const debugDraw = Object.assign(new JSDraw(), {
     /**
@@ -173,11 +165,11 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
      * @returns {void}
      */
     DrawSegment(vert1_p, vert2_p, color_p) {
-      const color = wrapPointer(color_p, b2Color);
-      setCtxColor(getRgbStr(color));
-      const vert1 = wrapPointer(vert1_p, b2Vec2);
-      const vert2 = wrapPointer(vert2_p, b2Vec2);
-      drawSegment(vert1, vert2);
+      const color = wrapPointer(color_p, b2Color)
+      setCtxColor(getRgbStr(color))
+      const vert1 = wrapPointer(vert1_p, b2Vec2)
+      const vert2 = wrapPointer(vert2_p, b2Vec2)
+      drawSegment(vert1, vert2)
     },
     /**
      * @param {number} vertices_p pointer to Array<{@link Box2D.b2Vec2}>
@@ -186,10 +178,10 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
      * @returns {void}
      */
     DrawPolygon(vertices_p, vertexCount, color_p) {
-      const color = wrapPointer(color_p, b2Color);
-      setCtxColor(getRgbStr(color));
-      const vertices = reifyArray(vertices_p, vertexCount, sizeOfB2Vec, b2Vec2);
-      drawPolygon(vertices, false);
+      const color = wrapPointer(color_p, b2Color)
+      setCtxColor(getRgbStr(color))
+      const vertices = reifyArray(vertices_p, vertexCount, sizeOfB2Vec, b2Vec2)
+      drawPolygon(vertices, false)
       // console.log(`DrawPolygon`, getRgbStr(color).green, vertices[0].y)
     },
     /**
@@ -199,10 +191,10 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
      * @returns {void}
      */
     DrawSolidPolygon(vertices_p, vertexCount, color_p) {
-      const color = wrapPointer(color_p, b2Color);
-      setCtxColor(getRgbStr(color));
-      const vertices = reifyArray(vertices_p, vertexCount, sizeOfB2Vec, b2Vec2);
-      drawPolygon(vertices, true);
+      const color = wrapPointer(color_p, b2Color)
+      setCtxColor(getRgbStr(color))
+      const vertices = reifyArray(vertices_p, vertexCount, sizeOfB2Vec, b2Vec2)
+      drawPolygon(vertices, true)
     },
     /**
      * @param {number} center_p pointer to {@link Box2D.b2Vec2}
@@ -211,11 +203,11 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
      * @returns {void}
      */
     DrawCircle(center_p, radius, color_p) {
-      const color = wrapPointer(color_p, b2Color);
-      setCtxColor(getRgbStr(color));
-      const center = wrapPointer(center_p, b2Vec2);
-      const dummyAxis = new b2Vec2(0, 0);
-      drawCircle(center, radius, dummyAxis, false);
+      const color = wrapPointer(color_p, b2Color)
+      setCtxColor(getRgbStr(color))
+      const center = wrapPointer(center_p, b2Vec2)
+      const dummyAxis = new b2Vec2(0, 0)
+      drawCircle(center, radius, dummyAxis, false)
     },
     /**
      * @param {number} center_p pointer to {@link Box2D.b2Vec2}
@@ -225,19 +217,19 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
      * @returns {void}
      */
     DrawSolidCircle(center_p, radius, axis_p, color_p) {
-      const color = wrapPointer(color_p, b2Color);
-      setCtxColor(getRgbStr(color));
-      const center = wrapPointer(center_p, b2Vec2);
-      const axis = wrapPointer(axis_p, b2Vec2);
-      drawCircle(center, radius, axis, true);
+      const color = wrapPointer(color_p, b2Color)
+      setCtxColor(getRgbStr(color))
+      const center = wrapPointer(center_p, b2Vec2)
+      const axis = wrapPointer(axis_p, b2Vec2)
+      drawCircle(center, radius, axis, true)
     },
     /**
      * @param {number} transform_p pointer to {@link Box2D.b2Transform}
      * @returns {void}
      */
     DrawTransform(transform_p) {
-      const transform = wrapPointer(transform_p, b2Transform);
-      drawTransform(transform);
+      const transform = wrapPointer(transform_p, b2Transform)
+      drawTransform(transform)
     },
     /**
      * @param {number} vertex_p pointer to {@link Box2D.b2Vec2}
@@ -246,12 +238,12 @@ export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof
      * @returns {void}
      */
     DrawPoint(vertex_p, sizeMetres, color_p) {
-      const color = wrapPointer(color_p, b2Color);
-      setCtxColor(getRgbStr(color));
-      const vertex = wrapPointer(vertex_p, b2Vec2);
-      drawPoint(vertex, sizeMetres);
-    }
-  });
-  debugDraw.SetFlags(e_shapeBit);
-  return debugDraw;
-};
+      const color = wrapPointer(color_p, b2Color)
+      setCtxColor(getRgbStr(color))
+      const vertex = wrapPointer(vertex_p, b2Vec2)
+      drawPoint(vertex, sizeMetres)
+    },
+  })
+  debugDraw.SetFlags(e_shapeBit)
+  return debugDraw
+}

package/src/components/NodeComp.ts

@@ -1,8 +1,9 @@
 import { Constructor, Entity } from 'entityx-ts'
 import { Action, actionManager, Animation } from 'pixi-action-ease'
 import { Color, ColorSource, Container, Point, Sprite, Text } from 'pixi.js'
-import { ComponentType, EnhancedComponent, instantiate } from '../base'
 
+import { ComponentType, EnhancedComponent, instantiate } from '../base'
+import { updatePoint, Vec2 } from '../core'
 import { Size } from '../core/Size'
 import { ProgressBarComp } from '../gui/GUIComponent'
 import { ExtraDataComp } from '../norender/NoRenderComponent'
@@ -12,7 +13,7 @@ export interface EventMap {
   [key: string]: [EventCallbackType]
 }
 
-type TouchEventCallback = (target: { location: Point }) => void
+type TouchEventCallback = (target: { location: Vec2 }) => void
 
 export class NodeComp<C extends Container = Container> {
   entity: Entity
@@ -36,7 +37,7 @@ export class NodeComp<C extends Container = Container> {
     this.onTouchStart = cb
     this.instance.on('touchstart', (event) => {
       const { global } = event
-      this.onTouchStart({ location: global })
+      this.onTouchStart({ location: updatePoint(global) })
     })
   }
 
@@ -44,7 +45,7 @@ export class NodeComp<C extends Container = Container> {
     this.onTouchMove = cb
     this.instance.on('touchmove', (event) => {
       const { global } = event
-      this.onTouchMove({ location: global })
+      this.onTouchMove({ location: updatePoint(global) })
     })
   }
 
@@ -52,7 +53,7 @@ export class NodeComp<C extends Container = Container> {
     this.onTouchEnd = cb
     this.instance.on('touchend', (event) => {
       const { global } = event
-      this.onTouchEnd({ location: global })
+      this.onTouchEnd({ location: updatePoint(global) })
     })
   }
 
@@ -60,7 +61,7 @@ export class NodeComp<C extends Container = Container> {
     this.onTouchCancel = cb
     this.instance.on('touchcancel', (event) => {
       const { global } = event
-      this.onTouchCancel({ location: global })
+      this.onTouchCancel({ location: updatePoint(global) })
     })
   }
 
@@ -74,11 +75,11 @@ export class NodeComp<C extends Container = Container> {
     return this.entity.id
   }
 
-  get position(): Point {
+  get position(): Vec2 {
     return this.getPosition()
   }
 
-  set position(val: Point) {
+  set position(val: Vec2) {
     this.setPosition(val.x, val.y)
   }
 
@@ -127,25 +128,21 @@ export class NodeComp<C extends Container = Container> {
   }
 
   get anchorX() {
-    if ((this.instance instanceof Sprite) || (this.instance instanceof Text))
-      return this.instance.anchor.x
+    if (this.instance instanceof Sprite || this.instance instanceof Text) return this.instance.anchor.x
     return 0
   }
 
   set anchorX(val: number) {
-    if ((this.instance instanceof Sprite) || (this.instance instanceof Text))
-      this.instance.anchor.x = val
+    if (this.instance instanceof Sprite || this.instance instanceof Text) this.instance.anchor.x = val
   }
 
   get anchorY() {
-    if ((this.instance instanceof Sprite) || (this.instance instanceof Text))
-      return this.instance.anchor.y
+    if (this.instance instanceof Sprite || this.instance instanceof Text) return this.instance.anchor.y
     return 0
   }
 
   set anchorY(val: number) {
-    if ((this.instance instanceof Sprite) || (this.instance instanceof Text))
-      this.instance.anchor.y = val
+    if (this.instance instanceof Sprite || this.instance instanceof Text) this.instance.anchor.y = val
   }
 
   /** rotation is in radians */
@@ -167,10 +164,8 @@ export class NodeComp<C extends Container = Container> {
   }
 
   get color() {
-    if (this.instance instanceof Sprite)
-      return this.instance.tint
-    if (this.instance instanceof Text)
-      return this.instance.style.fill as ColorSource
+    if (this.instance instanceof Sprite) return this.instance.tint
+    if (this.instance instanceof Text) return this.instance.style.fill as ColorSource
     return 0xffffff
   }
 
@@ -253,27 +248,27 @@ export class NodeComp<C extends Container = Container> {
     return this.getComponentsInChildren(component)[0]
   }
 
-  convertToNodeSpace(point: Point) {
+  convertToNodeSpace(point: Vec2) {
     return this.instance.toLocal(point)
   }
 
-  convertToNodeSpaceAR(point: Point) {
+  convertToNodeSpaceAR(point: Vec2) {
     return this.instance.toLocal(point)
   }
 
-  convertToWorldSpaceAR(point: Point) {
+  convertToWorldSpaceAR(point: Vec2) {
     return this.instance.toGlobal(point)
   }
 
-  getPosition(): Point {
-    return this.instance.position
+  getPosition(): Vec2 {
+    return updatePoint(this.instance.position)
   }
 
   setPosition(x: number | Point, y?: number) {
     if (typeof x !== 'number') {
-      this.instance.position = new Point(x.x, x.y)
+      this.instance.position = Vec2(x.x, x.y)
     } else {
-      this.instance.position = new Point(x, y)
+      this.instance.position = Vec2(x, y)
     }
   }
 
@@ -319,8 +314,7 @@ export class NodeComp<C extends Container = Container> {
   // }
 
   setColor(color: Color) {
-    if (this.instance instanceof Sprite)
-      (this.instance as Sprite).tint = color
+    if (this.instance instanceof Sprite) (this.instance as Sprite).tint = color
   }
 
   setScale(scaleX: number, scaleY?: number) {
@@ -385,6 +379,12 @@ export class NodeComp<C extends Container = Container> {
     })
   }
 
+  removeAllChildren() {
+    this.children.forEach((child) => {
+      child.removeFromParent()
+    })
+  }
+
   on(name: string, callback: EventCallbackType, target?: any) {
     const bound = target ? callback.bind(target) : callback
     if (this.events[name]) {
@@ -404,7 +404,7 @@ export class NodeComp<C extends Container = Container> {
     }
   }
 
-  resolveComponent(component: EnhancedComponent<{}, NodeComp>) {
+  resolveComponent(component: EnhancedComponent<object, NodeComp>) {
     // console.log(component.constructor.name, (component.constructor as any).hasRender)
     if ((component.constructor as any).hasRender) {
       this.addChild(component.node)

package/src/core/Vec2.ts

@@ -0,0 +1,108 @@
+import { Point } from 'pixi.js'
+
+import { clampf } from './math'
+
+export function updatePoint(p) {
+  const { x, y } = p
+  return Vec2(x, y)
+}
+
+class _Vec2 {
+  x: number
+  y: number
+  static ZERO
+  constructor(x: number | object = 0, y = 0) {
+    if (!(this instanceof _Vec2)) {
+      return new _Vec2(x, y)
+    }
+    if (typeof x === 'object') {
+      this.x = (x as any).x
+      this.y = (x as any).y
+      return
+    }
+    this.x = x
+    this.y = y
+  }
+
+  equals(other: _Vec2) {
+    return this.x === other.x && this.y === other.y
+  }
+
+  add(value: Point | Vec2): _Vec2 {
+    return updatePoint(new Point(this.x, this.y).add(value))
+  }
+
+  addSelf(value: Point | Vec2): _Vec2 {
+    const nor = updatePoint(new Point(this.x, this.y).add(value))
+    this.x = nor.x
+    this.y = nor.y
+    return nor
+  }
+
+  sub(value: Point | Vec2): _Vec2 {
+    return updatePoint(new Point(this.x, this.y).subtract(value))
+  }
+
+  mul(multiply: number): _Vec2 {
+    return updatePoint(new Point(this.x, this.y).multiply(new Point(multiply, multiply)))
+  }
+
+  mulSelf(multiply: number): _Vec2 {
+    const nor = updatePoint(new Point(this.x, this.y).multiply(new Point(multiply, multiply)))
+    this.x = nor.x
+    this.y = nor.y
+    return nor
+  }
+
+  mag(): number {
+    return new Point(this.x, this.y).magnitude()
+  }
+
+  normalizeSelf(): _Vec2 {
+    const nor = updatePoint(new Point(this.x, this.y).normalize())
+    this.x = nor.x
+    this.y = nor.y
+    return nor
+  }
+
+  normalize(): _Vec2 {
+    return updatePoint(new Point(this.x, this.y).normalize())
+  }
+
+  public cross(other: Vec2) {
+    return this.x * other.y - this.y * other.x
+  }
+  public signAngle(other: Vec2) {
+    const angle = this.angle(other)
+    return this.cross(other) < 0 ? -angle : angle
+  }
+  public lengthSqr() {
+    return this.x * this.x + this.y * this.y
+  }
+  public dot(other: Vec2) {
+    return this.x * other.x + this.y * other.y
+  }
+  public angle(other: Vec2) {
+    const magSqr1 = this.lengthSqr()
+    const magSqr2 = other.lengthSqr()
+
+    if (magSqr1 === 0 || magSqr2 === 0) {
+      console.warn('Cant get angle between zero vector')
+      return 0.0
+    }
+
+    const dot = this.dot(other)
+    let theta = dot / Math.sqrt(magSqr1 * magSqr2)
+    theta = clampf(theta, -1.0, 1.0)
+    return Math.acos(theta)
+  }
+  public distance(other: _Vec2) {
+    return this.sub(other).mag()
+  }
+}
+export type Vec2 = _Vec2
+export function Vec2(x?: number | object, y?: number): Vec2 {
+  return new _Vec2(x, y)
+}
+
+Vec2.ZERO = Object.freeze(Vec2(0, 0))

package/src/core/index.ts

@@ -0,0 +1,7 @@
+export * from './Color'
+export * from './director'
+export * from './loader'
+export * from './math'
+export * from './NodePool'
+// export * from './Size'
+export * from './Vec2'

package/src/core/loader.ts

@@ -0,0 +1,12 @@
+import { Assets } from 'pixi.js'
+
+const jsonCache = {}
+export async function loadJsonAsync<T>(filePath: string): Promise<T> {
+  const json = await Assets.load(filePath)
+  jsonCache[filePath] = json
+  return json
+}
+
+export function loadJsonFromCache<T>(filePath: string): T {
+  return jsonCache[filePath]
+}

package/src/core/math.ts

@@ -11,3 +11,12 @@ export function degreesToRadians(deg: Float) {
 export function radiansToDegrees(rad: Float) {
   return RAD_TO_DEG * rad
 }
+
+export function clampf(theta: number, arg1: number, arg2: number): number {
+  if (theta < arg1) {
+    return arg1
+  } else if (theta > arg2) {
+    return arg2
+  }
+  return theta
+}

package/src/gui/GUISystem.ts

@@ -1,16 +1,22 @@
 import { Button, CheckBox, List, RadioGroup, ScrollBox } from '@pixi/ui'
-import {
-  EventManager,
-  EventTypes,
-  System
-} from 'entityx-ts'
+import { EventManager, EventTypes, System } from 'entityx-ts'
 import { callFunc, easeBackIn, scaleTo, sequence } from 'pixi-action-ease'
 import { Text } from 'pixi.js'
 
 import { NodeComp } from '..'
 import { GameWorld } from '../base'
 import { LoadingBarMode, ProgressTimer } from '../core/LoadingBar'
-import { ButtonComp, CheckBoxComp, LabelComp, LabelOutlineComp, LabelShadowComp, ListComp, ProgressTimerComp, RadioGroupComp, ScrollView } from './GUIComponent'
+import {
+  ButtonComp,
+  CheckBoxComp,
+  LabelComp,
+  LabelOutlineComp,
+  LabelShadowComp,
+  ListComp,
+  ProgressTimerComp,
+  RadioGroupComp,
+  ScrollView,
+} from './GUIComponent'
 
 export class GUISystem implements System {
   defaultFont: string
@@ -89,9 +95,9 @@ export class GUISystem implements System {
       node.style.fill = '#fff'
       component.node = entity.assign(new NodeComp(node, entity))
       const { string = '', font = this.defaultFont, size = 64 } = component.props
-      if (font) component.font = (font)
-      component.size = (size)
-      component.string = (string)
+      if (font) component.font = font
+      component.size = size
+      component.string = string
     })
     event_manager.subscribe(EventTypes.ComponentAdded, LabelOutlineComp, ({ entity, component }) => {
       const { color, width } = component.props

package/src/index.ts

@@ -1,6 +1,5 @@
 export * from 'pixi-action-ease'
 export * from 'pixi.js'
-export { Vec2 } from 'planck'
 export * from './app'
 export * from './base'
 export * from './collider'
@@ -8,16 +7,15 @@ export * from './collider/helper/Intersection'
 export * from './components/BaseComponent'
 export * from './components/NodeComp'
 export * from './components/Scene'
-export * from './core/Color'
-export * from './core/director'
-export * from './core/math'
-export * from './core/NodePool'
+export * from './core'
 export * from './dragonbones'
 export * from './gui/GUIComponent'
 export * from './gui/GUISystem'
 export * from './helper/utils'
 export * from './norender/NoRenderComponent'
+export * from './norender/Touch'
 export * from './render/RenderComponent'
 export * from './render/RenderSystem'
 export * from './richtext'
 export * from './spine'
+