@safe-engine/pixi 8.4.6 → 8.5.1

package/src/box2d-wasm/PhysicsSprite.ts

@@ -1,42 +0,0 @@
-import { Container } from 'pixi.js'
-
-export class PhysicsSprite {
-  node: Container
-  physicsBody: Box2D.b2Body
-
-  constructor(node: Container, body: Box2D.b2Body) {
-    this.node = node
-    this.physicsBody = body
-  }
-
-  // set position(val: Box2D.b2Vec2) {
-  //   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: number) {
-  //   this.physicsBody.setAngle(val)
-  // }
-
-  get angle() {
-    return this.physicsBody.GetAngle()
-  }
-
-  addChild(child: Container) {
-    this.node.addChild(child)
-  }
-}

package/src/box2d-wasm/PhysicsSystem.ts

@@ -1,142 +0,0 @@
-import Box2DFactory from 'box2d-wasm'
-import { EntityManager, EventManager, EventTypes, System } from 'entityx-ts'
-import { Graphics } from 'pixi.js'
-
-import { GameWorld, instantiate, NodeComp, Vec2 } from '..'
-import { makeContactListener } from './ContactListener'
-import { makeDebugDraw } from './debugDraw'
-import {
-  BoxColliderPhysics,
-  CircleColliderPhysics,
-  ColliderPhysics,
-  PhysicsMaterial,
-  PolygonColliderPhysics,
-  RigidBody,
-} from './PhysicsComponent'
-import { PhysicsSprite } from './PhysicsSprite'
-
-// Box2D.b2Fixture.prototype.shouldCollide = function (other) {
-//   const nodeThis: NodeComp = this.getBody().getUserData()
-//   const nodeOther = other.getBody().getUserData() as NodeComp
-//   const { colliderMatrix } = GameWorld.Instance.systems.get(PhysicsSystem)
-//   return colliderMatrix[nodeOther.group][nodeThis.group]
-// }
-export let box2D: typeof Box2D
-export async function initBox2d() {
-  box2D = await Box2DFactory()
-}
-
-export function setColliderMatrix(colliderMatrix = [[true]]) {
-  const physicsSystem = GameWorld.Instance.systems.get(PhysicsSystem)
-  physicsSystem.colliderMatrix = colliderMatrix
-}
-const maxTimeStep = 1 / 60
-const velocityIterations = 1
-const positionIterations = 1
-const metadata: { [key: number]: NodeComp } = {}
-const pixelsPerMeter = 1
-
-export class PhysicsSystem implements System {
-  world: Box2D.b2World
-  listRemoveBody: Body[] = []
-  listRemoveShape: Box2D.b2Shape[] = []
-  colliderMatrix = [[true]]
-  graphics: Graphics
-
-  addDebug() {
-    const debugDraw = makeDebugDraw(this.graphics, pixelsPerMeter, box2D)
-    this.world.SetDebugDraw(debugDraw)
-  }
-
-  configure(event_manager: EventManager) {
-    const { b2BodyDef, b2_dynamicBody, b2_staticBody, b2FixtureDef, b2PolygonShape, b2Vec2, b2World, getPointer, b2ContactListener } =
-      box2D as typeof Box2D
-    const gravity = new b2Vec2(0, 10)
-    this.world = new b2World(gravity)
-    console.log('configure world', (event_manager.world as GameWorld).app)
-    // event_manager.world.physicsManager = this
-    const graphics = new Graphics()
-    this.graphics = graphics
-    graphics.zIndex = 1000
-    ;(event_manager.world as GameWorld).app.stage.addChild(graphics)
-    // 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 { type = 'static', gravityScale = 1 } = rigidBody.props
-      const physicsMaterial = entity.getComponent(PhysicsMaterial)
-      const { density = 1, friction = 0.5, restitution = 0.3 } = physicsMaterial?.props || {}
-      const box = component
-      const node = entity.getComponent(NodeComp)
-      const { width, height, ...colliderProps } = box.props
-      // ett.assign(instantiate(ColliderPhysics, { tag, offset }))
-      const { x = 0, y = 0 } = colliderProps.offset || {}
-      const zero = new b2Vec2(0, 0)
-      const position = new b2Vec2(node.posX, node.posY)
-      const offset = new b2Vec2(x, y)
-
-      const bd = new b2BodyDef()
-      bd.set_type(type === 'dynamic' ? b2_dynamicBody : b2_staticBody)
-      bd.set_position(zero)
-      bd.set_gravityScale(gravityScale)
-      const body = this.world.CreateBody(bd)
-      rigidBody.body = body
-      // console.log('body', type, b2_dynamicBody, b2_staticBody, getPointer(body));
-      // body.setMassData({ mass: 1 } as any)
-      const physicsNode = new PhysicsSprite(node.instance, body)
-      const square = new b2PolygonShape()
-      square.SetAsBox(width / 2, height / 2)
-      const fixtureDef = new b2FixtureDef()
-      fixtureDef.set_shape(square)
-      fixtureDef.set_density(density)
-      fixtureDef.set_friction(friction)
-      fixtureDef.set_restitution(restitution)
-      body.CreateFixture(fixtureDef)
-      body.SetTransform(position, 0)
-      body.SetLinearVelocity(zero)
-      body.SetAwake(true)
-      body.SetEnabled(true)
-      metadata[getPointer(body)] = node
-
-      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)
-      // }
-    })
-    const listener = makeContactListener(this.world, metadata, box2D)
-    this.world.SetContactListener(listener)
-  }
-
-  update(entities: EntityManager, events: EventManager, dt: number) {
-    if (this.world) {
-      const clampedDelta = Math.min(dt, maxTimeStep)
-      this.world.Step(clampedDelta, velocityIterations, positionIterations)
-      this.graphics.clear()
-      this.world.DebugDraw()
-      this.graphics.fill()
-      // this.graphics.stroke();
-      // console.log('GetBodyCount', this.world.GetBodyCount());
-    }
-  }
-
-  set gravity(val: Vec2) {
-    this.world.SetGravity(new box2D.b2Vec2(val.x, val.y))
-    // this.world.iterations = 60
-    // this.world.collisionSlop = 0.5
-  }
-}

package/src/box2d-wasm/debugDraw.ts

@@ -1,249 +0,0 @@
-import { Graphics } from 'pixi.js'
-
-import { Color4B } from '..'
-
-/**
- * Forked from Box2D.js
- * @see https://github.com/kripken/box2d.js/blob/f75077b/helpers/embox2d-helpers.js
- * @author dmagunov + Huy Nguyen + fork contributions from Alex Birch
- * @see https://github.com/kripken/box2d.js/blob/49dddd6/helpers/embox2d-html5canvas-debugDraw.js
- * @author dmagunov + fork contributions from Alex Birch
- * @license Zlib https://opensource.org/licenses/Zlib
- * License evidence: https://github.com/kripken/box2d.js/blob/master/README.markdown#box2djs
- *   "box2d.js is zlib licensed, just like Box2D."
- *
- * @typedef {import('box2d-wasm')} Box2DFactory
- * @param {CanvasRenderingContext2D} ctx
- * @param {number} pixelsPerMeter
- * @param {typeof Box2D & EmscriptenModule} box2D
- */
-export const makeDebugDraw = (graphics: Graphics, pixelsPerMeter, box2D: typeof Box2D) => {
-  const {
-    b2Color,
-    b2Draw: { e_shapeBit },
-    b2Transform,
-    b2Vec2,
-    JSDraw,
-    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())
-
-  /**
-   * to replace original C++ operator *= (float)
-   * @param {Box2D.b2Vec2} vec
-   * @param {number} scale
-   * @returns {Box2D.b2Vec2}
-   */
-  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)
-  }
-
-  /**
-   * @param {string} rgbStr
-   * @returns {void}
-   */
-  const setCtxColor = (rgbStr: Color4B) => {
-    graphics.fillStyle = rgbStr
-    graphics.strokeStyle = { color: rgbStr }
-  }
-
-  /**
-   * @param {Box2D.b2Vec2[]} vertices
-   * @param {boolean} fill
-   * @returns {void}
-   */
-  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)
-    vertices.forEach((v) => {
-      graphics.lineTo(v.x * pixelsPerMeter, v.y * pixelsPerMeter)
-    })
-    graphics.fill()
-  }
-
-  /**
-   * @param {Box2D.b2Vec2} center
-   * @param {number} radius
-   * @param {Box2D.b2Vec2} axis
-   * @param {boolean} fill
-   * @returns {void}
-   */
-  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
-
-    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
-    }
-    graphics.fill()
-  }
-
-  /**
-   * @param {Box2D.b2Vec2} vert1
-   * @param {Box2D.b2Vec2} vert2
-   * @returns {void}
-   */
-  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()
-  }
-
-  /**
-   * @param {Box2D.b2Vec2} vertex
-   * @param {number} sizeMetres
-   * @returns {void}
-   */
-  const drawPoint = (vertex, sizeMetres) => {
-    const sizePixels = sizeMetres / pixelsPerMeter
-    graphics.rect(vertex.get_x() - sizePixels / 2, vertex.get_y() - sizePixels / 2, sizePixels, sizePixels)
-  }
-
-  /**
-   * @param {Box2D.b2Transform} transform
-   * @param {number} sizeMetres
-   * @returns {void}
-   */
-  const drawTransform = (transform: Box2D.b2Transform) => {
-    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.lineWidth *= 2;
-    graphics.restore()
-  }
-
-  /** {@link Box2D.b2Vec2} is a struct of `float x, y` */
-  const sizeOfB2Vec = Float32Array.BYTES_PER_ELEMENT * 2
-
-  /**
-   * @param {number} array_p pointer to {@link Box2D.b2Vec2}
-   * @param {number} numElements length of array
-   * @param {number} sizeOfElement size of an instance of the array element
-   * @param {typeof Box2D.b2Vec2} ctor constructor for the array element
-   * @return {Box2D.b2Vec2[]}
-   */
-  const reifyArray = (array_p, numElements, sizeOfElement, ctor) =>
-    Array(numElements)
-      .fill(undefined)
-      .map((_, index) => wrapPointer(array_p + index * sizeOfElement, ctor))
-
-  const debugDraw = Object.assign(new JSDraw(), {
-    /**
-     * @param {number} vert1_p pointer to {@link Box2D.b2Vec2}
-     * @param {number} vert2_p pointer to {@link Box2D.b2Vec2}
-     * @param {number} color_p pointer to {@link Box2D.b2Color}
-     * @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)
-    },
-    /**
-     * @param {number} vertices_p pointer to Array<{@link Box2D.b2Vec2}>
-     * @param {number} vertexCount
-     * @param {number} color_p pointer to {@link Box2D.b2Color}
-     * @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)
-      // console.log(`DrawPolygon`, getRgbStr(color).green, vertices[0].y)
-    },
-    /**
-     * @param {number} vertices_p pointer to Array<{@link Box2D.b2Vec2}>
-     * @param {number} vertexCount
-     * @param {number} color_p pointer to {@link Box2D.b2Color}
-     * @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)
-    },
-    /**
-     * @param {number} center_p pointer to {@link Box2D.b2Vec2}
-     * @param {number} radius
-     * @param {number} color_p pointer to {@link Box2D.b2Color}
-     * @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)
-    },
-    /**
-     * @param {number} center_p pointer to {@link Box2D.b2Vec2}
-     * @param {number} radius
-     * @param {number} axis_p pointer to {@link Box2D.b2Vec2}
-     * @param {number} color_p pointer to {@link Box2D.b2Color}
-     * @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)
-    },
-    /**
-     * @param {number} transform_p pointer to {@link Box2D.b2Transform}
-     * @returns {void}
-     */
-    DrawTransform(transform_p) {
-      const transform = wrapPointer(transform_p, b2Transform)
-      drawTransform(transform)
-    },
-    /**
-     * @param {number} vertex_p pointer to {@link Box2D.b2Vec2}
-     * @param {number} sizeMetres
-     * @param {number} pointer to {@link Box2D.b2Color}
-     * @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
-}

package/src/box2d-wasm/index.ts

@@ -1,19 +0,0 @@
-import { GameWorld, Vec2 } from '..'
-import { PhysicsSystem } from './PhysicsSystem'
-
-export * from './PhysicsComponent'
-export * from './PhysicsSprite'
-export * from './PhysicsSystem'
-
-export function setupPhysics(world = GameWorld.Instance, isDebugDraw?: boolean, gravity?: Vec2) {
-  console.log('app world', world.app)
-  world.systems.add(PhysicsSystem)
-  world.systems.configureOnce(PhysicsSystem)
-  world.listUpdate.push(PhysicsSystem)
-  if (isDebugDraw) {
-    world.systems.get(PhysicsSystem).addDebug()
-  }
-  if (gravity) {
-    world.systems.get(PhysicsSystem).gravity = gravity
-  }
-}