@safe-engine/pixi 8.4.7 → 8.5.1

package/src/base/EnhancedComponent.ts

@@ -1,38 +0,0 @@
-import { Constructor } from 'entityx-ts'
-import { BaseComponentProps } from '..'
-import { NodeComp } from '../components/NodeComp'
-
-export class EnhancedComponent<Props = {}, N extends NodeComp<any> = NodeComp<any>> {
-  props: Props = {} as any
-  enabled = true
-  constructor(data?: BaseComponentProps<EnhancedComponent> & Props) {
-    this.init(data)
-  }
-  init(data?: Props) {
-    if (data) {
-      // console.log('constructor', this.constructor.name, data)
-      Object.keys(data).forEach((key) => {
-        this.props[key] = data[key]
-      })
-    }
-  }
-  node: N
-
-  addComponent<T extends EnhancedComponent>(instance): T {
-    return this.node.addComponent(instance)
-  }
-  getComponent<T extends ComponentType>(component: Constructor<T>): T {
-    return this.node.getComponent(component)
-  }
-  getComponentsInChildren<T extends ComponentType>(component: Constructor<T>): T[] {
-    return this.node.getComponentsInChildren(component)
-  }
-  getComponentInChildren<T extends ComponentType>(component: Constructor<T>): T {
-    return this.node.getComponentInChildren(component)
-  }
-  isEqual(other: EnhancedComponent) {
-    return this.node.entity.id === other.node.entity.id
-  }
-}
-
-export type ComponentType = EnhancedComponent | NodeComp

package/src/base/gworld.ts

@@ -1,20 +0,0 @@
-import { Constructor, System, World } from 'entityx-ts'
-import { Application, AssetsClass } from 'pixi.js'
-
-export class GameWorld extends World {
-  listUpdate: (System | Constructor<System>)[] = []
-  app: Application
-  assetManager: AssetsClass
-  update(dt: number) {
-    this.listUpdate.forEach((system: any) => {
-      this.systems.update(system, dt)
-    })
-  }
-
-  private static _instance: GameWorld
-
-  public static get Instance() {
-    // Do you need arguments? Make it a regular static method instead.
-    return this._instance || (this._instance = new this())
-  }
-}

package/src/base/index.ts

@@ -1,14 +0,0 @@
-import { NodeComp } from '../components/NodeComp'
-
-export * from './EnhancedComponent'
-export * from './gworld'
-export * from './utils'
-
-export interface BaseComponentProps<T> {
-  $ref?: T
-  $push?: T[]
-  $refNode?: NodeComp
-  $pushNode?: NodeComp[]
-  node?: Partial<NodeComp>
-  // [$key: `$${string}`]: string
-}

package/src/base/utils.ts

@@ -1,23 +0,0 @@
-import { Constructor } from 'entityx-ts'
-
-import { GameWorld } from '..'
-import { ComponentX, NoRenderComponentX } from '../components/BaseComponent'
-
-export type GetProps<T> = T extends ComponentX<infer P> ? P : T extends NoRenderComponentX<infer Q> ? Q : never
-
-export function instantiate<T extends ComponentX>(ComponentType: Constructor<T>, data?: GetProps<T>): T {
-  const instance = new ComponentType()
-  instance.init(data)
-  // console.log(ComponentType.name, data, instance)
-  if (!instance.render) {
-    return instance
-  }
-  return instance.render()
-}
-
-export function loadScene<T extends ComponentX>(ComponentType: Constructor<T>) {
-  const world = GameWorld.Instance
-  world.entities.reset()
-  const instance = new ComponentType()
-  instance.render()
-}

package/src/box2d-wasm/ContactListener.ts

@@ -1,66 +0,0 @@
-import { NodeComp } from "..";
-import { ColliderPhysics } from "./PhysicsComponent";
-type Meta = { [key: number]: NodeComp }
-export const makeContactListener = (world: Box2D.b2World, metadata: Meta, box2D: typeof Box2D) => {
-  const { JSContactListener, getPointer, NULL } = box2D
-  function getContactById(contact: number) {
-    for (let contactList = world.GetContactList(); getPointer(contactList) !== getPointer(NULL); contactList = contactList.GetNext()) {
-      if (getPointer(contactList) === contact) {
-        console.log('contactBegin', contact, getPointer(contactList), getPointer(NULL));
-        return contactList
-      }
-    }
-  }
-  const listener = Object.assign(new JSContactListener(), {
-    BeginContact(contact: Box2D.b2Contact | number): void {
-      if (typeof contact === 'number') {
-        contact = getContactById(contact)
-      }
-      const ett1: NodeComp = metadata[getPointer(contact.GetFixtureA().GetBody())]
-      const ett2: NodeComp = metadata[getPointer(contact.GetFixtureB().GetBody())]
-      // world.addPostStepCallback(() => {
-      //   // log('addPostStepCallback');
-      //   listRemoveShape.forEach((s) => world.removeShape(s))
-      //   listRemoveBody.forEach((b) => world.removeBody(b))
-      //   listRemoveBody = []
-      //   listRemoveShape = []
-      // })
-      const phys1 = ett1.getComponent(ColliderPhysics)
-      const phys2 = ett2.getComponent(ColliderPhysics)
-      if (phys1 && phys2) {
-        if (Object.prototype.hasOwnProperty.call(phys1, 'onCollisionEnter')) {
-          phys1.props.onCollisionEnter(phys2)
-        }
-        if (Object.prototype.hasOwnProperty.call(phys2, 'onCollisionEnter')) {
-          phys2.props.onCollisionEnter(phys1)
-        }
-      }
-    },
-    EndContact(contact: Box2D.b2Contact | number): void {
-      if (typeof contact === 'number') {
-        contact = getContactById(contact)
-      }
-      const ett1: NodeComp = metadata[getPointer(contact.GetFixtureA().GetBody())]
-      const ett2: NodeComp = metadata[getPointer(contact.GetFixtureB().GetBody())]
-      // 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.props.onCollisionExit(phys2)
-        }
-        if (Object.prototype.hasOwnProperty.call(phys2, 'onCollisionExit')) {
-          phys2.props.onCollisionExit(phys1)
-        }
-      }
-    },
-    PreSolve(contact: Box2D.b2Contact | number, oldManifold: Box2D.b2Manifold | number): void {
-      console.log('collisionSeparate');
-    },
-    PostSolve(contact: Box2D.b2Contact | number, impulse: Box2D.b2ContactImpulse | number): void {
-      console.log('collisionPost');
-    }
-  });
-  return listener
-}

package/src/box2d-wasm/PhysicsComponent.ts

@@ -1,83 +0,0 @@
-import { BodyType, Vec2 } from 'planck'
-import { NoRenderComponentX } from '..'
-import { PhysicsSprite } from './PhysicsSprite'
-
-interface RigidBodyProps {
-  type?: BodyType
-  density?: Float
-  restitution?: Float
-  friction?: Float
-  gravityScale?: Float
-}
-
-export class RigidBody extends NoRenderComponentX<RigidBodyProps> {
-  body: Box2D.b2Body
-  // 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)
-  // }
-}
-
-interface PhysicsMaterialProps {
-  friction?: number
-  restitution?: number
-  density?: number
-}
-export class PhysicsMaterial extends NoRenderComponentX<PhysicsMaterialProps> {
-
-}
-
-interface ColliderPhysicsProps {
-  tag?: number
-  group?: number
-  offset?: Vec2
-  onCollisionEnter?: (other: ColliderPhysics) => void
-  onCollisionExit?: (other: ColliderPhysics) => void
-  onCollisionStay?: (other: ColliderPhysics) => void
-}
-
-export class ColliderPhysics<T extends ColliderPhysicsProps = ColliderPhysicsProps> extends NoRenderComponentX<T, PhysicsSprite['node']> {
-  enabled = true
-  instance: PhysicsSprite
-}
-
-interface BoxColliderPhysicsProps extends ColliderPhysicsProps {
-  width: number
-  height: number
-}
-export class BoxColliderPhysics extends ColliderPhysics<BoxColliderPhysicsProps> {
-
-  // set onCollisionEnter(val) {
-  //   const phys1 = this.getComponent(ColliderPhysics)
-  //   phys1._onCollisionEnter = val
-  // }
-
-  // get onCollisionEnter() {
-  //   const phys1 = this.getComponent(ColliderPhysics)
-  //   return phys1._onCollisionEnter
-  // }
-}
-interface CircleColliderPhysicsProps extends ColliderPhysicsProps {
-  radius: number
-}
-export class CircleColliderPhysics extends ColliderPhysics<CircleColliderPhysicsProps> {
-}
-interface PolygonColliderPhysicsProps extends ColliderPhysicsProps {
-  points: Array<Vec2>
-}
-export class PolygonColliderPhysics extends ColliderPhysics<PolygonColliderPhysicsProps> {
-}

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
-}