@tushar-br/desktop 1.0.173 → 1.0.174

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/src/worker/index.ts

@@ -0,0 +1,281 @@
+/// <reference no-default-lib="true"/>
+/// <reference lib="esnext" />
+/// <reference lib="webworker" />
+
+import { GSSolver, HingeConstraint, NaiveBroadphase, SAPBroadphase, Vec3 } from 'cannon-es'
+
+import type { CannonMessage } from '../types'
+import { addContactMaterial, removeContactMaterial } from './contact-material'
+import { createMaterialFactory } from './material'
+import { addBodies, addConstraint, addRay, addRaycastVehicle, addSpring, init, step } from './operations'
+import { state } from './state'
+import type { CannonWorkerGlobalScope } from './types'
+
+// TODO: Declare this for all files in worker
+declare const self: CannonWorkerGlobalScope
+
+const isHingeConstraint = (c: unknown): c is HingeConstraint => c instanceof HingeConstraint
+
+function syncBodies() {
+  state.bodiesNeedSyncing = true
+  state.bodies = state.world.bodies.reduce(
+    (bodies, body) => (body.uuid ? { ...bodies, [body.uuid]: body } : bodies),
+    {},
+  )
+}
+
+const broadphases = { NaiveBroadphase, SAPBroadphase }
+const createMaterial = createMaterialFactory(state.materials)
+
+self.onmessage = ({ data }: { data: CannonMessage }) => {
+  switch (data.op) {
+    case 'init': {
+      init(state.world, data.props)
+      break
+    }
+    case 'step': {
+      step(state, data)
+      break
+    }
+    case 'addBodies': {
+      addBodies(state, createMaterial, data)
+      syncBodies()
+      break
+    }
+    case 'removeBodies': {
+      for (let i = 0; i < data.uuid.length; i++) {
+        state.world.removeBody(state.bodies[data.uuid[i]])
+        const key = Object.keys(state.subscriptions).find((k) => state.subscriptions[k][0] === data.uuid[i])
+        if (key) {
+          delete state.subscriptions[key]
+        }
+      }
+      syncBodies()
+      break
+    }
+    case 'subscribe': {
+      const { id, target, type } = data.props
+      state.subscriptions[id] = [data.uuid, type, target]
+      break
+    }
+    case 'unsubscribe': {
+      delete state.subscriptions[data.props]
+      break
+    }
+    case 'setPosition':
+      state.bodies[data.uuid].position.set(data.props[0], data.props[1], data.props[2])
+      break
+    case 'setQuaternion':
+      state.bodies[data.uuid].quaternion.set(data.props[0], data.props[1], data.props[2], data.props[3])
+      break
+    case 'setRotation':
+      state.bodies[data.uuid].quaternion.setFromEuler(data.props[0], data.props[1], data.props[2])
+      break
+    case 'setVelocity':
+      state.bodies[data.uuid].velocity.set(data.props[0], data.props[1], data.props[2])
+      break
+    case 'setAngularVelocity':
+      state.bodies[data.uuid].angularVelocity.set(data.props[0], data.props[1], data.props[2])
+      break
+    case 'setLinearFactor':
+      state.bodies[data.uuid].linearFactor.set(data.props[0], data.props[1], data.props[2])
+      break
+    case 'setAngularFactor':
+      state.bodies[data.uuid].angularFactor.set(data.props[0], data.props[1], data.props[2])
+      break
+    case 'setMass':
+      state.bodies[data.uuid].mass = data.props
+      state.bodies[data.uuid].updateMassProperties()
+      break
+    case 'setMaterial':
+      state.bodies[data.uuid].material = data.props ? createMaterial(data.props) : null
+      break
+    case 'setLinearDamping':
+      state.bodies[data.uuid].linearDamping = data.props
+      break
+    case 'setAngularDamping':
+      state.bodies[data.uuid].angularDamping = data.props
+      break
+    case 'setAllowSleep':
+      state.bodies[data.uuid].allowSleep = data.props
+      break
+    case 'setSleepSpeedLimit':
+      state.bodies[data.uuid].sleepSpeedLimit = data.props
+      break
+    case 'setSleepTimeLimit':
+      state.bodies[data.uuid].sleepTimeLimit = data.props
+      break
+    case 'setCollisionFilterGroup':
+      state.bodies[data.uuid].collisionFilterGroup = data.props
+      break
+    case 'setCollisionFilterMask':
+      state.bodies[data.uuid].collisionFilterMask = data.props
+      break
+    case 'setCollisionResponse':
+      state.bodies[data.uuid].collisionResponse = data.props
+      break
+    case 'setFixedRotation':
+      state.bodies[data.uuid].fixedRotation = data.props
+      break
+    case 'setFrictionGravity':
+      state.world.frictionGravity = data.props ? new Vec3(...data.props) : undefined
+      break
+    case 'setIsTrigger':
+      state.bodies[data.uuid].isTrigger = data.props
+      break
+    case 'setGravity':
+      state.world.gravity.set(data.props[0], data.props[1], data.props[2])
+      break
+    case 'setTolerance':
+      if (state.world.solver instanceof GSSolver) {
+        state.world.solver.tolerance = data.props
+      }
+      break
+    case 'setIterations':
+      if (state.world.solver instanceof GSSolver) {
+        state.world.solver.iterations = data.props
+      }
+      break
+    case 'setBroadphase':
+      state.world.broadphase = new (broadphases[`${data.props}Broadphase`] || NaiveBroadphase)(state.world)
+      break
+    case 'setAxisIndex':
+      if (state.world.broadphase instanceof SAPBroadphase) {
+        state.world.broadphase.axisIndex = data.props === undefined || data.props === null ? 0 : data.props
+      }
+      break
+    case 'applyForce':
+      state.bodies[data.uuid].applyForce(new Vec3(...data.props[0]), new Vec3(...data.props[1]))
+      break
+    case 'applyImpulse':
+      state.bodies[data.uuid].applyImpulse(new Vec3(...data.props[0]), new Vec3(...data.props[1]))
+      break
+    case 'applyLocalForce':
+      state.bodies[data.uuid].applyLocalForce(new Vec3(...data.props[0]), new Vec3(...data.props[1]))
+      break
+    case 'applyLocalImpulse':
+      state.bodies[data.uuid].applyLocalImpulse(new Vec3(...data.props[0]), new Vec3(...data.props[1]))
+      break
+    case 'applyTorque':
+      state.bodies[data.uuid].applyTorque(new Vec3(...data.props[0]))
+      break
+    case 'addConstraint': {
+      addConstraint(state, data)
+      break
+    }
+    case 'removeConstraint':
+      state.world.constraints
+        .filter(({ uuid }) => uuid === data.uuid)
+        .map((c) => state.world.removeConstraint(c))
+      if (state.constraints[data.uuid]) {
+        state.world.removeEventListener('postStep', state.constraints[data.uuid])
+        delete state.constraints[data.uuid]
+      }
+      break
+    case 'enableConstraint':
+      state.world.constraints.filter((c) => c.uuid === data.uuid).map((c) => c.enable())
+      break
+    case 'disableConstraint':
+      state.world.constraints.filter((c) => c.uuid === data.uuid).map((c) => c.disable())
+      break
+    case 'enableConstraintMotor':
+      state.world.constraints
+        .filter((c) => c.uuid === data.uuid)
+        .filter(isHingeConstraint)
+        .map((c) => c.enableMotor())
+      break
+    case 'disableConstraintMotor':
+      state.world.constraints
+        .filter((c) => c.uuid === data.uuid)
+        .filter(isHingeConstraint)
+        .map((c) => c.disableMotor())
+      break
+    case 'setConstraintMotorSpeed':
+      state.world.constraints
+        .filter((c) => c.uuid === data.uuid)
+        .filter(isHingeConstraint)
+        .map((c) => c.setMotorSpeed(data.props))
+      break
+    case 'setConstraintMotorMaxForce':
+      state.world.constraints
+        .filter((c) => c.uuid === data.uuid)
+        .filter(isHingeConstraint)
+        .map((c) => c.setMotorMaxForce(data.props))
+      break
+    case 'addSpring': {
+      addSpring(state, data)
+      break
+    }
+    case 'setSpringStiffness': {
+      state.springInstances[data.uuid].stiffness = data.props
+      break
+    }
+    case 'setSpringRestLength': {
+      state.springInstances[data.uuid].restLength = data.props
+      break
+    }
+    case 'setSpringDamping': {
+      state.springInstances[data.uuid].damping = data.props
+      break
+    }
+    case 'removeSpring': {
+      state.world.removeEventListener('postStep', state.springs[data.uuid])
+      break
+    }
+    case 'addRay': {
+      addRay(state, data)
+      break
+    }
+    case 'removeRay': {
+      state.world.removeEventListener('preStep', state.rays[data.uuid])
+      delete state.rays[data.uuid]
+      break
+    }
+    case 'addRaycastVehicle': {
+      addRaycastVehicle(state, data)
+      break
+    }
+    case 'removeRaycastVehicle': {
+      state.world.removeEventListener('preStep', state.vehicles[data.uuid].preStep)
+      state.world.removeEventListener('postStep', state.vehicles[data.uuid].postStep)
+      state.vehicles[data.uuid].vehicle.world = null
+      delete state.vehicles[data.uuid]
+      const key = Object.keys(state.subscriptions).find((k) => state.subscriptions[k][0] === data.uuid)
+      if (key) {
+        delete state.subscriptions[key]
+      }
+      break
+    }
+    case 'setRaycastVehicleSteeringValue': {
+      const [value, wheelIndex] = data.props
+      state.vehicles[data.uuid].vehicle.setSteeringValue(value, wheelIndex)
+      break
+    }
+    case 'applyRaycastVehicleEngineForce': {
+      const [value, wheelIndex] = data.props
+      state.vehicles[data.uuid].vehicle.applyEngineForce(value, wheelIndex)
+      break
+    }
+    case 'setRaycastVehicleBrake': {
+      const [brake, wheelIndex] = data.props
+      state.vehicles[data.uuid].vehicle.setBrake(brake, wheelIndex)
+      break
+    }
+    case 'addContactMaterial': {
+      addContactMaterial(state.world, createMaterial, data.props, data.uuid)
+      break
+    }
+    case 'removeContactMaterial': {
+      removeContactMaterial(state.world, data.uuid)
+      break
+    }
+    case 'wakeUp': {
+      state.bodies[data.uuid].wakeUp()
+      break
+    }
+    case 'sleep': {
+      state.bodies[data.uuid].sleep()
+      break
+    }
+  }
+}

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/src/worker/material.ts

@@ -0,0 +1,23 @@
+import { Material } from 'cannon-es'
+
+type MaterialOptions = {
+  friction?: number
+  name?: string | symbol
+  restitution?: number
+}
+
+export type CreateMaterial = (nameOrOptions?: MaterialOptions | string) => Material
+
+let materialId = 0
+
+export const createMaterialFactory =
+  (materials: Record<string | symbol, Material>): CreateMaterial =>
+  (nameOrOptions = {}) => {
+    const materialOptions =
+      typeof nameOrOptions === 'string'
+        ? { name: nameOrOptions }
+        : { name: Symbol.for(`Material${materialId++}`), ...nameOrOptions }
+    const { name } = materialOptions
+    materials[name] = materials[name] || new Material(materialOptions)
+    return materials[name]
+  }

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/src/worker/operations/add-bodies.ts

@@ -0,0 +1,60 @@
+import { propsToBody } from '../../props-to-body'
+import type { CannonMessageMap } from '../../types'
+import type { CreateMaterial } from '../material'
+import type { State } from '../state'
+import type { CannonCollideEvent, CannonWorkerGlobalScope } from '../types'
+
+declare const self: CannonWorkerGlobalScope
+
+export const addBodies = (
+  state: State,
+  createMaterial: CreateMaterial,
+  { props, type, uuid }: CannonMessageMap['addBodies'],
+) => {
+  for (let i = 0; i < uuid.length; i++) {
+    const body = propsToBody({
+      createMaterial,
+      props: props[i],
+      type,
+      uuid: uuid[i],
+    })
+    state.world.addBody(body)
+
+    if (props[i].onCollide)
+      body.addEventListener('collide', ({ type, body, target, contact }: CannonCollideEvent) => {
+        if (!body.uuid || !target.uuid) return
+
+        const { ni, ri, rj, bi, bj, id } = contact
+        const contactPoint = bi.position.vadd(ri)
+        const contactNormal = bi === body ? ni : ni.scale(-1)
+
+        self.postMessage({
+          body: body.uuid,
+          collisionFilters: {
+            bodyFilterGroup: body.collisionFilterGroup,
+            bodyFilterMask: body.collisionFilterMask,
+            targetFilterGroup: target.collisionFilterGroup,
+            targetFilterMask: target.collisionFilterMask,
+          },
+          contact: {
+            // @ts-expect-error TODO: use id instead of uuid
+            bi: bi.uuid,
+            // @ts-expect-error TODO: use id instead of uuid
+            bj: bj.uuid,
+            // Normal of the contact, relative to the colliding body
+            contactNormal: contactNormal.toArray(),
+            // World position of the contact
+            contactPoint: contactPoint.toArray(),
+            id,
+            impactVelocity: contact.getImpactVelocityAlongNormal(),
+            ni: ni.toArray(),
+            ri: ri.toArray(),
+            rj: rj.toArray(),
+          },
+          op: 'event',
+          target: target.uuid,
+          type,
+        })
+      })
+  }
+}

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/src/worker/operations/add-constraint.ts

@@ -0,0 +1,101 @@
+import {
+  ConeTwistConstraint,
+  Constraint,
+  DistanceConstraint,
+  HingeConstraint,
+  LockConstraint,
+  PointToPointConstraint,
+} from 'cannon-es'
+
+import type { CannonMessageMap } from '../../types'
+import type { State } from '../state'
+import { tripletToVec3 } from '../triplet-to-vec3'
+import type { WithUUID } from '../types'
+
+export const addConstraint = (
+  state: State,
+  {
+    props: [
+      bodyA,
+      bodyB,
+      {
+        angle,
+        axisA,
+        axisB,
+        collideConnected,
+        distance,
+        maxForce,
+        maxMultiplier,
+        pivotA,
+        pivotB,
+        twistAngle,
+        wakeUpBodies,
+      },
+    ],
+    type,
+    uuid,
+  }: CannonMessageMap['addConstraint'],
+) => {
+  let constraint: WithUUID<Constraint>
+
+  switch (type) {
+    case 'PointToPoint':
+      constraint = new PointToPointConstraint(
+        state.bodies[bodyA],
+        tripletToVec3(pivotA),
+        state.bodies[bodyB],
+        tripletToVec3(pivotB),
+        maxForce,
+      )
+      break
+    case 'ConeTwist':
+      constraint = new ConeTwistConstraint(state.bodies[bodyA], state.bodies[bodyB], {
+        angle,
+        axisA: tripletToVec3(axisA),
+        axisB: tripletToVec3(axisB),
+        collideConnected,
+        maxForce,
+        pivotA: tripletToVec3(pivotA),
+        pivotB: tripletToVec3(pivotB),
+        twistAngle,
+      })
+      break
+    case 'Hinge':
+      constraint = new HingeConstraint(state.bodies[bodyA], state.bodies[bodyB], {
+        axisA: tripletToVec3(axisA),
+        axisB: tripletToVec3(axisB),
+        collideConnected,
+        maxForce,
+        pivotA: tripletToVec3(pivotA),
+        pivotB: tripletToVec3(pivotB),
+      })
+      break
+    case 'Distance':
+      constraint = new DistanceConstraint(state.bodies[bodyA], state.bodies[bodyB], distance, maxForce)
+      break
+    case 'Lock':
+      constraint = new LockConstraint(state.bodies[bodyA], state.bodies[bodyB], { maxForce })
+      break
+    default:
+      constraint = new Constraint(state.bodies[bodyA], state.bodies[bodyB], {
+        collideConnected,
+        wakeUpBodies,
+      })
+      break
+  }
+  constraint.uuid = uuid
+  state.world.addConstraint(constraint)
+
+  if (maxMultiplier !== undefined) {
+    const postStepConstraint = () => {
+      // The multiplier is proportional to how much force is added to the bodies by the constraint.
+      // If this exceeds a limit the constraint is disabled.
+      const multiplier = Math.abs(constraint.equations[0].multiplier)
+      if (multiplier > maxMultiplier) {
+        constraint.disable()
+      }
+    }
+    state.constraints[uuid] = postStepConstraint
+    state.world.addEventListener('postStep', state.constraints[uuid])
+  }
+}

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/src/worker/operations/add-ray.ts

@@ -0,0 +1,60 @@
+import type { Body, RayOptions } from 'cannon-es'
+import { Ray, RAY_MODES, RaycastResult } from 'cannon-es'
+
+import type { CannonMessageMap } from '../../types'
+import type { State } from '../state'
+import { tripletToVec3 } from '../triplet-to-vec3'
+import type { CannonWorkerGlobalScope, WithUUID } from '../types'
+
+declare const self: CannonWorkerGlobalScope
+
+function toUppercase<T extends string>(str: T): Uppercase<T> {
+  return str.toUpperCase() as Uppercase<T>
+}
+
+export const addRay = (
+  state: State,
+  { props: { from, mode, to, ...rayOptions }, uuid }: CannonMessageMap['addRay'],
+) => {
+  const ray = new Ray(tripletToVec3(from), tripletToVec3(to))
+
+  const options: RayOptions = {
+    mode: RAY_MODES[toUppercase(mode)],
+    result: new RaycastResult(),
+    ...rayOptions,
+  }
+
+  state.rays[uuid] = () => {
+    ray.intersectWorld(state.world, options)
+
+    if (!options.result || !options.result.body) return
+
+    const { body, shape, rayFromWorld, rayToWorld, hitNormalWorld, hitPointWorld, ...rest } = options.result
+
+    const bodyUUID = (body as WithUUID<Body>).uuid
+
+    if (!bodyUUID) return
+
+    self.postMessage({
+      body: bodyUUID,
+      hitNormalWorld: hitNormalWorld.toArray(),
+      hitPointWorld: hitPointWorld.toArray(),
+      op: 'event',
+      ray: {
+        collisionFilterGroup: ray.collisionFilterGroup,
+        collisionFilterMask: ray.collisionFilterMask,
+        direction: ray.direction.toArray(),
+        from,
+        to,
+        uuid,
+      },
+      rayFromWorld: rayFromWorld.toArray(),
+      rayToWorld: rayToWorld.toArray(),
+      shape: shape ? { ...shape, body: bodyUUID } : null,
+      type: 'rayhit',
+      ...rest,
+    })
+  }
+
+  state.world.addEventListener('preStep', state.rays[uuid])
+}

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/src/worker/operations/add-raycast-vehicle.ts

@@ -0,0 +1,50 @@
+import { RaycastVehicle } from 'cannon-es'
+
+import type { CannonMessageMap } from '../../types'
+import type { State } from '../state'
+import { tripletToVec3 } from '../triplet-to-vec3'
+
+export const addRaycastVehicle = (state: State, data: CannonMessageMap['addRaycastVehicle']) => {
+  const [chassisBody, wheels, wheelInfos, indexForwardAxis, indexRightAxis, indexUpAxis] = data.props
+
+  const vehicle = new RaycastVehicle({
+    chassisBody: state.bodies[chassisBody],
+    indexForwardAxis,
+    indexRightAxis,
+    indexUpAxis,
+  })
+
+  vehicle.world = state.world
+
+  for (let i = 0; i < wheelInfos.length; i++) {
+    const { axleLocal, chassisConnectionPointLocal, directionLocal, ...rest } = wheelInfos[i]
+
+    vehicle.addWheel({
+      axleLocal: tripletToVec3(axleLocal),
+      chassisConnectionPointLocal: tripletToVec3(chassisConnectionPointLocal),
+      directionLocal: tripletToVec3(directionLocal),
+      ...rest,
+    })
+  }
+
+  const preStep = () => {
+    vehicle.updateVehicle(state.world.dt)
+  }
+
+  const postStep = () => {
+    for (let i = 0; i < vehicle.wheelInfos.length; i++) {
+      vehicle.updateWheelTransform(i)
+
+      const t = vehicle.wheelInfos[i].worldTransform
+      const wheelBody = state.bodies[wheels[i]]
+
+      wheelBody.position.copy(t.position)
+      wheelBody.quaternion.copy(t.quaternion)
+    }
+  }
+
+  state.vehicles[data.uuid] = { postStep, preStep, vehicle }
+
+  state.world.addEventListener('preStep', preStep)
+  state.world.addEventListener('postStep', postStep)
+}

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/src/worker/operations/add-spring.ts

@@ -0,0 +1,38 @@
+import { Spring } from 'cannon-es'
+
+import type { CannonMessageMap } from '../../types'
+import type { State } from '../state'
+import { tripletToVec3 } from '../triplet-to-vec3'
+import type { WithUUID } from '../types'
+
+export const addSpring = (
+  state: State,
+  {
+    props: [
+      bodyA,
+      bodyB,
+      { damping, localAnchorA, localAnchorB, restLength, stiffness, worldAnchorA, worldAnchorB },
+    ],
+    uuid,
+  }: CannonMessageMap['addSpring'],
+) => {
+  const spring: WithUUID<Spring> = new Spring(state.bodies[bodyA], state.bodies[bodyB], {
+    damping,
+    localAnchorA: tripletToVec3(localAnchorA),
+    localAnchorB: tripletToVec3(localAnchorB),
+    restLength,
+    stiffness,
+    worldAnchorA: tripletToVec3(worldAnchorA),
+    worldAnchorB: tripletToVec3(worldAnchorB),
+  })
+
+  spring.uuid = uuid
+
+  const postStepSpring = () => spring.applyForce()
+
+  state.springs[uuid] = postStepSpring
+  state.springInstances[uuid] = spring
+
+  // Compute the force after each step
+  state.world.addEventListener('postStep', state.springs[uuid])
+}

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/src/worker/operations/index.ts

@@ -0,0 +1,7 @@
+export { addBodies } from './add-bodies'
+export { addConstraint } from './add-constraint'
+export { addRay } from './add-ray'
+export { addRaycastVehicle } from './add-raycast-vehicle'
+export { addSpring } from './add-spring'
+export { init } from './init'
+export { step } from './step'

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/src/worker/operations/init.ts

@@ -0,0 +1,66 @@
+import type { Body } from 'cannon-es'
+import { GSSolver, NaiveBroadphase, SAPBroadphase, SplitSolver, Vec3 } from 'cannon-es'
+
+import type { CannonMessageProps } from '../../types'
+import type { DecoratedWorld } from '../state'
+import type { CannonWorkerGlobalScope, WithUUID } from '../types'
+
+declare const self: CannonWorkerGlobalScope
+
+type TwoBodies = {
+  bodyA?: WithUUID<Body>
+  bodyB?: WithUUID<Body>
+}
+
+function emitBeginContact({ bodyA, bodyB }: TwoBodies) {
+  if (!bodyA?.uuid || !bodyB?.uuid) return
+  self.postMessage({ bodyA: bodyA.uuid, bodyB: bodyB.uuid, op: 'event', type: 'collideBegin' })
+}
+
+function emitEndContact({ bodyA, bodyB }: TwoBodies) {
+  if (!bodyA?.uuid || !bodyB?.uuid) return
+  self.postMessage({ bodyA: bodyA.uuid, bodyB: bodyB.uuid, op: 'event', type: 'collideEnd' })
+}
+
+export const init = (
+  world: DecoratedWorld,
+  {
+    allowSleep,
+    axisIndex = 0,
+    broadphase,
+    defaultContactMaterial,
+    frictionGravity,
+    gravity,
+    iterations,
+    quatNormalizeFast,
+    quatNormalizeSkip,
+    solver,
+    tolerance,
+  }: CannonMessageProps<'init'>,
+): void => {
+  world.allowSleep = allowSleep
+  world.gravity.set(...gravity)
+  world.frictionGravity = frictionGravity ? new Vec3(...frictionGravity) : undefined
+  world.quatNormalizeFast = quatNormalizeFast
+  world.quatNormalizeSkip = quatNormalizeSkip
+
+  if (solver === 'Split') {
+    world.solver = new SplitSolver(new GSSolver())
+  }
+
+  if (world.solver instanceof GSSolver) {
+    world.solver.tolerance = tolerance
+    world.solver.iterations = iterations
+  }
+
+  world.broadphase = broadphase === 'SAP' ? new SAPBroadphase(world) : new NaiveBroadphase()
+
+  if (world.broadphase instanceof SAPBroadphase) {
+    world.broadphase.axisIndex = axisIndex
+  }
+
+  world.addEventListener('beginContact', emitBeginContact)
+  world.addEventListener('endContact', emitEndContact)
+
+  Object.assign(world.defaultContactMaterial, defaultContactMaterial)
+}