@perplexdotgg/bounce 1.0.0

package/src/world.ts

@@ -0,0 +1,1335 @@
+import { InputType, PartialRecursive, WithPool } from "monomorph";
+import { CastRayResult, CollideBodiesModule, CollideBodiesSettings } from "./physics/narrowphase/CollideBodiesModule";
+import {
+  ActiveEdgeMode,
+  BackFaceMode,
+  CollectFacesMode,
+  CollisionCollector,
+  CollisionResult,
+  CollisionSettings,
+} from "./collision/collide/collide";
+import { CollideShapesModule } from "./collision/CollideShapesModule";
+import { CoefficientFunctionType, ContactConstraintModule } from "./physics/solver/ContactConstraintModule";
+import { ContactManifoldModule } from "./physics/manifold/ContactManifoldModule";
+import { GjkModule } from "./collision/gjk/GjkModule";
+import { PenetrationDepthModule } from "./collision/gjk/PenetrationDepthModule";
+import { SleepModule, SleepOptions } from "./physics/SleepModule";
+import { transformTensor } from "./math/tensor";
+import { Vec3 } from "./math/vec3";
+import { Body, BodyType, updateBody, updateWorldBounds } from "./physics/Body";
+import { Sphere } from "./shape/Sphere";
+import { Box } from "./shape/Box";
+import { Ray } from "./shape/Ray";
+import { BasicTransform } from "./math/BasicTransform";
+import { DynamicShape, KinematicShape, Shape, ShapeType, StaticShape } from "./shape/Shape";
+import { BvhModule, BvhModuleOptions } from "./physics/broadphase/BvhModule";
+import { ManifoldCacheOptions } from "./physics/manifold/ManifoldCache";
+import { CompoundShape } from "./shape/CompoundShape";
+import { TransformedShape } from "./shape/TransformedShape";
+import { CastShapesModule } from "./collision/CastShapesModule";
+import { HeightMapBuilder } from "./builders/HeightMapBuilder";
+import { ConvexHullBuilder } from "./builders/ConvexHullBuilder";
+import ConvexHull, { ConvexHullFace, ConvexHullPoint } from "./shape/ConvexHull";
+import { Cylinder } from "./shape/Cylinder";
+import { BuildTriangleMeshParams, TriangleMeshBuilder } from "./builders/TriangleMeshBuilder";
+import { TriangleMesh } from "./shape/TriangleMesh";
+import { ConstraintSolver } from "./constraints/ConstraintSolver";
+import { CastCollector, createDefaultCastSettings, QueryPrecision, RayCastSettings } from "./collision/cast/cast";
+import { AllFlag } from "./physics/CollisionFilter";
+import { Isometry } from "./math/isometry";
+import { Capsule } from "./shape/Capsule";
+import { ContactManifold, createContactPairKey } from "./physics/manifold/ContactManifold";
+import { EstimateCollisionResponseResult } from "./physics/solver/estimateCollisionResponse";
+import { PointConstraint } from "./constraints/PointConstraint";
+import { FixedConstraint } from "./constraints/FixedConstraint";
+import { DistanceConstraint } from "./constraints/DistanceConstraint";
+import { HingeConstraint } from "./constraints/HingeConstraint";
+import { ConstraintPairEdge, ConstraintPairNode, ConstraintPairsModule } from "./physics/broadphase/ConstraintPairsModule";
+import { Constraint } from "./constraints/types";
+import { HeightMap } from "./shape/HeightMap";
+import { TriangleMeshBvhNode as TriangleMeshBvhNode, TriangleMeshBvhTree } from "./physics/broadphase/TriangleMeshBvhTree";
+import { Triangle } from "./shape/Triangle";
+import { Plane } from "./shape/Plane";
+import { NumberValue } from "./math/NumberValue";
+import { BodyPairEdge, BodyPairNode } from "./physics/broadphase/BodyPairsModule";
+import { BvhNode } from "./physics/broadphase/BvhTree";
+
+const shapeCenterOfMassInWorldSpace = /*@__PURE__*/ Vec3.create() as Vec3;
+
+interface WorldOptions {
+  gravity: InputType<Vec3>;
+  broadphaseOptions: PartialRecursive<BvhModuleOptions>;
+  isGravityEnabled: boolean;
+  restitution: number;
+  friction: number;
+  solveVelocityIterations: number;
+  solvePositionIterations: number;
+  linearDamping: number;
+  angularDamping: number;
+  frictionFunction: CoefficientFunctionType;
+  restitutionFunction: CoefficientFunctionType;
+  minVelocityForElasticContact: number;
+  baumgarte: number;
+  penetrationSlop: number;
+  maxPenetrationDistance: number;
+  speculativeContactDistance: number;
+  collisionTolerance: number;
+  maxLinearSpeed: number;
+  maxAngularSpeed: number;
+  isWarmStartingEnabled: boolean;
+  collideShapeSettings: CollisionSettings;
+  timeStepSizeSeconds: number;
+  maxTimeToSimulateSeconds: number;
+  sleepOptions?: PartialRecursive<SleepOptions>;
+  contactManifoldOptions?: PartialRecursive<ManifoldCacheOptions>;
+}
+
+/**
+ * a container and API for a physics simulation
+ */
+export class World {
+  options: WorldOptions;
+  gravity: Vec3;
+
+  collideBodiesSettings: CollideBodiesSettings;
+  maxLinearSpeedSquared: number;
+  maxAngularSpeedSquared: number;
+
+  collideShapesModule: CollideShapesModule;
+  castShapesModule: CastShapesModule;
+
+  collideBodiesModule: CollideBodiesModule;
+  sleepModule: SleepModule;
+
+  heightMapBuilder: HeightMapBuilder;
+  convexHullBuilder: ConvexHullBuilder;
+  triangleMeshBuilder: TriangleMeshBuilder;
+
+  constraintSolver: ConstraintSolver;
+
+  dynamicBodyCopies: typeof Body.ReferenceList;
+  kinematicBodyCopies: typeof Body.ReferenceList;
+  staticBodyCopies: typeof Body.ReferenceList;
+
+  dynamicBodies: typeof Body.ReferenceList;
+  kinematicBodies: typeof Body.ReferenceList;
+  staticBodies: typeof Body.ReferenceList;
+
+  pools: {
+    // shapes
+    sphere: typeof Sphere.Pool;
+    box: typeof Box.Pool;
+    capsule: typeof Capsule.Pool;
+    cylinder: typeof Cylinder.Pool;
+    convexHullFace: typeof ConvexHullFace.Pool;
+    convexHullNumberValue: typeof NumberValue.Pool;
+    convexHullPlane: typeof Plane.Pool;
+    convexHullPoint: typeof ConvexHullPoint.Pool;
+    convexHullVec3: typeof Vec3.Pool;
+    convexHull: typeof ConvexHull.Pool;
+    transformedShape: typeof TransformedShape.Pool;
+    triangleMeshBvhNode: typeof TriangleMeshBvhNode.Pool;
+    triangleMeshVertexPosition: typeof Vec3.Pool;
+    triangleMeshFaceIndex: typeof Vec3.Pool;
+    triangleMeshTriangle: typeof Triangle.Pool;
+    triangleMeshBvhTree: typeof TriangleMeshBvhTree.Pool;
+    triangleMesh: typeof TriangleMesh.Pool;
+    compoundShape: typeof CompoundShape.Pool;
+    heightMap: typeof HeightMap.Pool;
+    sphereCopy: typeof Sphere.Pool;
+    boxCopy: typeof Box.Pool;
+    capsuleCopy: typeof Capsule.Pool;
+    cylinderCopy: typeof Cylinder.Pool;
+    convexHullCopy: typeof ConvexHull.Pool;
+    triangleMeshCopy: typeof TriangleMesh.Pool;
+    compoundShapeCopy: typeof CompoundShape.Pool;
+    heightMapCopy: typeof HeightMap.Pool;
+
+    // bvh
+    bvhNodes: typeof BvhNode.Pool;
+
+    constraintPairNode: typeof ConstraintPairNode.Pool;
+    constraintPairEdge: typeof ConstraintPairEdge.Pool;
+
+    // bodies
+    body: typeof Body.Pool;
+    bodyCopy: typeof Body.Pool;
+
+    // body pairs
+    bodyPairNode: typeof BodyPairNode.Pool;
+    bodyPairEdge: typeof BodyPairEdge.Pool;
+  };
+
+  broadphase: BvhModule;
+
+  step: number;
+  lastAdvanceTimeCall: number | null;
+  advanceTimeAccumulatedSeconds: number;
+  maxTimeToSimulateSeconds: number;
+
+  previousTimeStepSizeSeconds: number;
+
+  constructor(options: PartialRecursive<WorldOptions> = {}) {
+    this.options = {
+      gravity: { x: 0, y: -9.80665, z: 0 },
+      broadphaseOptions: undefined,
+      isGravityEnabled: true,
+      restitution: 0,
+      friction: 0,
+      solveVelocityIterations: 6,
+      solvePositionIterations: 2,
+      linearDamping: 0.05,
+      angularDamping: 0.05,
+      frictionFunction: CoefficientFunctionType.max,
+      restitutionFunction: CoefficientFunctionType.max,
+      minVelocityForElasticContact: 2,
+      baumgarte: 0.2,
+      penetrationSlop: 0.02,
+      maxPenetrationDistance: 0.2,
+      speculativeContactDistance: 0.02,
+      collisionTolerance: 1e-4,
+      maxLinearSpeed: 30.0,
+      maxAngularSpeed: 30.0,
+      isWarmStartingEnabled: true,
+      collideShapeSettings: {
+        maxSeparation: 0.02,
+        collisionTolerance: 1e-4,
+        activeEdgeMode: ActiveEdgeMode.CollideOnlyWithActive,
+        collectFacesMode: CollectFacesMode.NoFaces,
+        penetrationTolerance: 1e-4,
+        activeEdgeMovementDirectionX: 0,
+        activeEdgeMovementDirectionY: 0,
+        activeEdgeMovementDirectionZ: 0,
+        backFaceMode: BackFaceMode.IgnoreBackFaces,
+      },
+      timeStepSizeSeconds: 1 / 60,
+      maxTimeToSimulateSeconds: 1,
+      sleepOptions: undefined,
+      contactManifoldOptions: undefined,
+      ...options,
+    } as WorldOptions;
+
+    this.collideBodiesSettings = { speculativeContactDistance: this.options.speculativeContactDistance };
+    this.maxLinearSpeedSquared = this.options.maxLinearSpeed * this.options.maxLinearSpeed;
+    this.maxAngularSpeedSquared = this.options.maxAngularSpeed * this.options.maxAngularSpeed;
+    this.gravity = Vec3.create(this.options.gravity);
+
+
+    this.pools = {
+      // shapes
+      box: new Box.Pool(),
+      boxCopy: new Box.Pool(),
+      capsule: new Capsule.Pool(),
+      capsuleCopy: new Capsule.Pool(),
+      compoundShape: new CompoundShape.Pool(),
+      compoundShapeCopy: new CompoundShape.Pool(),
+      convexHullFace: new ConvexHullFace.Pool(),
+      convexHullNumberValue: new NumberValue.Pool(),
+      convexHullPlane: new Plane.Pool(),
+      convexHullPoint: new ConvexHullPoint.Pool(),
+      convexHullVec3: new Vec3.Pool(),
+      convexHull: new ConvexHull.Pool(),
+      convexHullCopy: new ConvexHull.Pool(),
+      cylinder: new Cylinder.Pool(),
+      cylinderCopy: new Cylinder.Pool(),
+      heightMap: new HeightMap.Pool(),
+      heightMapCopy: new HeightMap.Pool(),
+      sphere: new Sphere.Pool(),
+      sphereCopy: new Sphere.Pool(),
+      transformedShape: new TransformedShape.Pool(),
+      triangleMesh: new TriangleMesh.Pool(),
+      triangleMeshBvhNode: new TriangleMeshBvhNode.Pool(),
+      triangleMeshBvhTree: new TriangleMeshBvhTree.Pool(),
+      triangleMeshCopy: new TriangleMesh.Pool(),
+      triangleMeshFaceIndex: new Vec3.Pool(),
+      triangleMeshTriangle: new Triangle.Pool(),
+      triangleMeshVertexPosition: new Vec3.Pool(),
+
+      bvhNodes: new BvhNode.Pool(),
+
+      constraintPairNode: new ConstraintPairNode.Pool(),
+      constraintPairEdge: new ConstraintPairEdge.Pool(),
+
+      body: new Body.Pool(),
+      bodyCopy: new Body.Pool(),
+
+      bodyPairEdge: new BodyPairEdge.Pool(),
+      bodyPairNode: new BodyPairNode.Pool(),
+    };
+
+
+
+    this.broadphase = new BvhModule(this, (this.options.broadphaseOptions as BvhModuleOptions) || undefined);
+    const gjkModule = new GjkModule();
+    const penetrationDepthModule = new PenetrationDepthModule(gjkModule);
+    const collideShapesModule = new CollideShapesModule(penetrationDepthModule);
+    const castShapesModule = new CastShapesModule(penetrationDepthModule);
+    this.collideShapesModule = collideShapesModule;
+    this.castShapesModule = castShapesModule;
+    const contactManifoldModule = new ContactManifoldModule(this.options.contactManifoldOptions);
+    const contactConstraintModule = new ContactConstraintModule(this, contactManifoldModule);
+    const constraintPairs = new ConstraintPairsModule(this.pools.constraintPairNode, this.pools.constraintPairEdge);
+    const sleepModule = new SleepModule(this.broadphase.pairs, constraintPairs, this.options.sleepOptions);
+    this.collideBodiesModule = new CollideBodiesModule(
+      this,
+      collideShapesModule,
+      castShapesModule,
+      contactManifoldModule,
+      contactConstraintModule,
+      sleepModule
+    );
+
+    this.heightMapBuilder = new HeightMapBuilder();
+    this.convexHullBuilder = new ConvexHullBuilder();
+    this.triangleMeshBuilder = new TriangleMeshBuilder();
+
+    this.constraintSolver = new ConstraintSolver(this, constraintPairs);
+
+    this.sleepModule = sleepModule;
+
+
+    this.dynamicBodyCopies = new Body.ReferenceList(this.pools.bodyCopy);
+    this.kinematicBodyCopies = new Body.ReferenceList(this.pools.bodyCopy);
+    this.staticBodyCopies = new Body.ReferenceList(this.pools.bodyCopy);
+
+    this.dynamicBodies = new Body.ReferenceList(this.pools.body);
+    this.kinematicBodies = new Body.ReferenceList(this.pools.body);
+    this.staticBodies = new Body.ReferenceList(this.pools.body);
+
+    this.step = 0;
+    this.lastAdvanceTimeCall = null;
+    this.advanceTimeAccumulatedSeconds = 0;
+    this.maxTimeToSimulateSeconds = this.options.maxTimeToSimulateSeconds;
+
+    this.previousTimeStepSizeSeconds = this.options.timeStepSizeSeconds;
+  }
+
+
+  collideBodiesWithBroadphase(
+    timeStepSizeSeconds: number,
+    isWarmStartingEnabled: boolean,
+    minVelocityForElasticContact: number
+  ) {
+    this.collideBodiesModule.contactManifoldModule.flipCache();
+    this.collideBodiesModule.contactConstraintModule.clearContactConstraints();
+
+    for (let pair of this.broadphase.iteratePairs()) {
+      this.collideBodiesModule.collideBodies(
+        pair.bodyA!,
+        pair.bodyB!,
+        this.options.collideShapeSettings,
+        this.collideBodiesSettings,
+        timeStepSizeSeconds,
+        isWarmStartingEnabled,
+        minVelocityForElasticContact
+      );
+    }
+  }
+
+  *iterateOverBodyPairsBruteForce() {
+    for (const bodyA of this.dynamicBodies) {
+      for (const bodyB of this.dynamicBodies) {
+        // skip self
+        if (bodyA === bodyB) {
+          continue;
+        }
+
+        // skip already checked pairs
+        if (bodyA.index > bodyB.index) {
+          continue;
+        }
+
+        yield [bodyA, bodyB];
+      }
+
+      for (const bodyB of this.kinematicBodies) {
+        yield [bodyA, bodyB];
+      }
+
+      for (const bodyB of this.staticBodies) {
+        yield [bodyA, bodyB];
+      }
+    }
+  }
+
+  collideBodiesWithoutBroadphase(
+    timeStepSizeSeconds: number,
+    isWarmStartingEnabled: boolean,
+    minVelocityForElasticContact: number
+  ) {
+    this.collideBodiesModule.contactManifoldModule.flipCache();
+    this.collideBodiesModule.contactConstraintModule.clearContactConstraints();
+    // this.collideBodiesModule.contactManifoldModule.bodiesInContact.clear(); // TODO
+
+    for (const bodyA of this.dynamicBodies) {
+      for (const bodyB of this.dynamicBodies) {
+        // skip self
+        if (bodyA === bodyB) {
+          continue;
+        }
+
+        // skip already checked pairs
+        if (bodyA.index > bodyB.index) {
+          continue;
+        }
+
+        // skip if bounds have no overlap
+        if (bodyA.computedBounds.intersectsAabb(bodyB.computedBounds) === false) {
+          continue;
+        }
+
+        this.collideBodiesModule.collideBodies(
+          bodyA,
+          bodyB,
+          this.options.collideShapeSettings,
+          this.collideBodiesSettings,
+          timeStepSizeSeconds,
+          isWarmStartingEnabled,
+          minVelocityForElasticContact
+        );
+      }
+
+      for (const bodyB of this.kinematicBodies) {
+        // skip if bounds have no overlap
+        if (bodyA.computedBounds.intersectsAabb(bodyB.computedBounds) === false) {
+          continue;
+        }
+
+        this.collideBodiesModule.collideBodies(
+          bodyA,
+          bodyB,
+          this.options.collideShapeSettings,
+          this.collideBodiesSettings,
+          timeStepSizeSeconds,
+          isWarmStartingEnabled,
+          minVelocityForElasticContact
+        );
+      }
+
+      for (const bodyB of this.staticBodies) {
+        // skip if bounds have no overlap
+        if (bodyA.computedBounds.intersectsAabb(bodyB.computedBounds) === false) {
+          continue;
+        }
+
+        this.collideBodiesModule.collideBodies(
+          bodyA,
+          bodyB,
+          this.options.collideShapeSettings,
+          this.collideBodiesSettings,
+          timeStepSizeSeconds,
+          isWarmStartingEnabled,
+          minVelocityForElasticContact
+        );
+      }
+    }
+  }
+
+  /**
+   * integrates the acceleration of all bodies
+   */
+  applyAccelerationIntegration(
+    bodies: typeof Body.Pool | typeof Body.ReferenceList,
+    timeStepSizeSeconds: number,
+    gravity: Vec3,
+    isGravityEnabled: boolean,
+    linearDamping: number,
+    angularDamping: number,
+    maxLinearSpeed: number,
+    maxLinearSpeedSquared: number,
+    maxAngularSpeed: number,
+    maxAngularSpeedSquared: number
+  ) {
+    for (const body of bodies) {
+      if (body.isSleeping) {
+        continue;
+      }
+
+      body.applyAccelerationIntegration(
+        timeStepSizeSeconds,
+        gravity,
+        isGravityEnabled,
+        linearDamping,
+        angularDamping,
+        maxLinearSpeed,
+        maxLinearSpeedSquared,
+        maxAngularSpeed,
+        maxAngularSpeedSquared
+      );
+    }
+  }
+
+  /**
+   * integrates the linear velocity of all bodies
+   */
+  applyVelocityIntegration(bodies: typeof Body.Pool | typeof Body.ReferenceList, timeStepSizeSeconds: number) {
+    for (const body of bodies) {
+      if (body.isSleeping) {
+        continue;
+      }
+      body.applyLinearVelocityIntegration(timeStepSizeSeconds);
+      body.applyAngularVelocityIntegration(timeStepSizeSeconds);
+      this.broadphase.markDynamicBodyAsDirty(body);
+    }
+  }
+
+  solveVelocityConstraintsInterleaved(
+    isWarmStartingEnabled: boolean,
+    solveVelocityIterations: number,
+    deltaTimeSeconds: number,
+    warmStartImpulseRatio: number
+  ) {
+    // contact constraints have already been initialized
+    this.constraintSolver.initVelocityConstraints(deltaTimeSeconds);
+
+    if (isWarmStartingEnabled) {
+      this.constraintSolver.warmStartConstraints(deltaTimeSeconds, warmStartImpulseRatio);
+      this.collideBodiesModule.contactConstraintModule.warmStartConstraints();
+    }
+
+    for (let i = 0; i < solveVelocityIterations; i++) {
+      this.constraintSolver.solveVelocityConstraintsStep(deltaTimeSeconds);
+      this.collideBodiesModule.contactConstraintModule.solveVelocityConstraintsStep();
+    }
+
+    // this.collideBodiesModule.contactConstraintModule.logLambdas();
+  }
+
+  solvePositionConstraintsInterleaved(
+    solvePositionIterations: number,
+    penetrationSlop: number,
+    maxPenetrationDistance: number,
+    baumgarte: number,
+    deltaTimeSeconds: number
+  ) {
+    for (let i = 0; i < solvePositionIterations; i++) {
+      this.constraintSolver.solvePositionConstraintsStep(deltaTimeSeconds);
+      this.collideBodiesModule.contactConstraintModule.solvePositionConstraintsStep(
+        penetrationSlop,
+        maxPenetrationDistance,
+        baumgarte
+      );
+    }
+  }
+
+  updateWorldInverseInertias(bodies: typeof Body.Pool | typeof Body.ReferenceList) {
+    // update world inverse inertias
+    for (const body of bodies) {
+      transformTensor(body.computedWorldInverseInertia, body.computedLocalInverseInertia, body.orientation);
+    }
+  }
+
+  updateCachedBodyData(bodies: typeof Body.Pool | typeof Body.ReferenceList) {
+    for (const body of bodies) {
+      shapeCenterOfMassInWorldSpace.copy(body.shape!.computedCenterOfMass);
+      shapeCenterOfMassInWorldSpace.transformByQuat(body.orientation);
+      body.position.subtractVectors(body.computedCenterOfMassPosition, shapeCenterOfMassInWorldSpace);
+      updateWorldBounds(body);
+    }
+  }
+
+  // updateBodyProperties() {
+  //   for (const body of this.bodies()) {
+  //     // updateBody(body);
+  //   }
+  // }
+
+  clearForcesOnBodies() {
+    for (const body of this.dynamicBodies) {
+      body.clearForces();
+    }
+  }
+
+  // stepping API
+  takeOneStep(timeStepSizeSeconds?: number) {
+    // console.log("before step", this.broadphase.dynamicTree.dirtyObjects.size);
+    // this.broadphase.updateDirtyBodies();
+    timeStepSizeSeconds = timeStepSizeSeconds ?? this.options.timeStepSizeSeconds;
+    const warmStartImpulseRatio = timeStepSizeSeconds / this.previousTimeStepSizeSeconds;
+    // this.updateCachedBodyData(this.dynamicBodies);
+    // this.updateCachedBodyData(this.staticBodies);
+    // this.broadphase.updateDirtyBodies();
+    this.applyAccelerationIntegration(
+      this.dynamicBodies,
+      timeStepSizeSeconds,
+      this.gravity,
+      this.options.isGravityEnabled,
+      this.options.linearDamping,
+      this.options.angularDamping,
+      this.options.maxLinearSpeed,
+      this.maxLinearSpeedSquared,
+      this.options.maxAngularSpeed,
+      this.maxAngularSpeedSquared
+    );
+    // this.collideBodiesWithoutBroadphase(
+    //   timeStepSizeSeconds,
+    //   this.options.isWarmStartingEnabled,
+    //   this.options.minVelocityForElasticContact
+    // );
+    this.collideBodiesWithBroadphase(
+      timeStepSizeSeconds,
+      this.options.isWarmStartingEnabled,
+      this.options.minVelocityForElasticContact
+    );
+    this.solveVelocityConstraintsInterleaved(
+      this.options.isWarmStartingEnabled,
+      this.options.solveVelocityIterations,
+      timeStepSizeSeconds,
+      warmStartImpulseRatio
+    );
+    if (this.options.isWarmStartingEnabled) {
+      this.collideBodiesModule.contactConstraintModule.cacheLambdas();
+    }
+    this.applyVelocityIntegration(this.dynamicBodies, timeStepSizeSeconds);
+    this.solvePositionConstraintsInterleaved(
+      this.options.solvePositionIterations,
+      this.options.penetrationSlop,
+      this.options.maxPenetrationDistance,
+      this.options.baumgarte,
+      timeStepSizeSeconds
+    );
+    this.updateWorldInverseInertias(this.dynamicBodies);
+    this.sleepModule.updateBodySleepStates(this.dynamicBodies, timeStepSizeSeconds);
+    this.updateCachedBodyData(this.dynamicBodies);
+    this.updateCachedBodyData(this.kinematicBodies);
+    this.updateCachedBodyData(this.staticBodies);
+    this.clearForcesOnBodies();
+    // this.broadphase.updateDirtyBodies();
+    // console.log("after step", this.broadphase.dynamicTree.dirtyObjects.size);
+    this.step++;
+    this.previousTimeStepSizeSeconds = timeStepSizeSeconds;
+  }
+
+  advanceTime(timeStepSizeSeconds?: number, timeToSimulateSeconds?: number) {
+    // compute current time
+    const nowSeconds = performance.now() / 1000;
+
+    // compute time step size
+    if (!timeStepSizeSeconds) {
+      timeStepSizeSeconds = this.options.timeStepSizeSeconds;
+    }
+
+    // compute time to simulate. if first call, we use time step size to start it off
+    if (!timeToSimulateSeconds) {
+      if (!this.lastAdvanceTimeCall) {
+        timeToSimulateSeconds = timeStepSizeSeconds;
+      } else {
+        timeToSimulateSeconds = nowSeconds - this.lastAdvanceTimeCall;
+      }
+    }
+    timeToSimulateSeconds = Math.min(timeToSimulateSeconds, this.maxTimeToSimulateSeconds);
+
+    // take as many steps that fit into the time to simulate
+    this.advanceTimeAccumulatedSeconds += timeToSimulateSeconds;
+    while (this.advanceTimeAccumulatedSeconds >= timeStepSizeSeconds) {
+      this.takeOneStep(timeStepSizeSeconds);
+      this.advanceTimeAccumulatedSeconds -= timeStepSizeSeconds;
+    }
+
+    // update last advance time call
+    this.lastAdvanceTimeCall = this.lastAdvanceTimeCall ?? nowSeconds;
+  }
+
+  // shapes API
+  createSphere(options: InputType<Sphere>) {
+    const shape = Sphere.create(options, this.pools.sphere);
+
+    const shapeCopy = Sphere.create(options, this.pools.sphereCopy);
+    shapeCopy.copy(shape);
+    shape.copyForDiff = shapeCopy;
+
+    shape.world = this;
+    return shape;
+  }
+
+  createBox(options: InputType<Box>) {
+    const shape = Box.create(options, this.pools.box);
+
+    const shapeCopy = Box.create(options, this.pools.boxCopy);
+    shapeCopy.copy(shape);
+    shape.copyForDiff = shapeCopy;
+
+    shape.world = this;
+    return shape;
+  }
+
+  createCylinder(options: InputType<Cylinder>) {
+    const shape = Cylinder.create(options, this.pools.cylinder);
+
+    const shapeCopy = Cylinder.create(options, this.pools.cylinderCopy);
+    shapeCopy.copy(shape);
+    shape.copyForDiff = shapeCopy;
+
+    shape.world = this;
+    return shape;
+  }
+
+  createCapsule(options: InputType<Capsule>) {
+    const shape = Capsule.create(options, this.pools.capsule);
+
+    const shapeCopy = Capsule.create(options, this.pools.capsuleCopy);
+    shapeCopy.copy(shape);
+    shape.copyForDiff = shapeCopy;
+
+    shape.world = this;
+    return shape;
+  }
+
+  createTriangleMesh(params: BuildTriangleMeshParams) {
+    const shape = this.triangleMeshBuilder.build(
+      params,
+      this.pools.triangleMesh,
+      this.pools.triangleMeshBvhNode,
+      this.pools.triangleMeshBvhTree,
+      this.pools.triangleMeshVertexPosition,
+      this.pools.triangleMeshFaceIndex,
+      this.pools.triangleMeshTriangle,
+    );
+
+    const shapeCopy = TriangleMesh.create({
+      vertexPositions: { pool: this.pools.triangleMeshVertexPosition },
+      faceIndices: { pool: this.pools.triangleMeshFaceIndex },
+      triangles: { pool: this.pools.triangleMeshTriangle },
+    }, this.pools.triangleMeshCopy);
+    shapeCopy.copy(shape);
+    shape.copyForDiff = shapeCopy;
+
+    shape.world = this;
+    return shape;
+  }
+
+  createConvexHull(vertices: Float32Array, convexRadius: number = 0.02, hullTolerance: number = 1e-3) {
+    const shape = this.convexHullBuilder.buildFromPoints(
+      vertices,
+      convexRadius,
+      hullTolerance,
+      this.pools.convexHull,
+      this.pools.convexHullFace,
+      this.pools.convexHullNumberValue,
+      this.pools.convexHullPlane,
+      this.pools.convexHullPoint,
+      this.pools.convexHullVec3,
+    ) as WithPool<ConvexHull>;
+
+    const shapeCopy = ConvexHull.create({
+      faces: { pool: this.pools.convexHullFace },
+      vertexIdx: { pool: this.pools.convexHullNumberValue },
+      planes: { pool: this.pools.convexHullPlane },
+      points: { pool: this.pools.convexHullPoint },
+      shapeNoConvexPoints: { pool: this.pools.convexHullVec3 },
+    }, this.pools.convexHullCopy);
+    shapeCopy.copy(shape);
+    shape.copyForDiff = shapeCopy;
+
+    shape.world = this;
+    return shape;
+  }
+
+  createCompoundShape(
+    params: {
+      shape: Shape;
+      transform: InputType<BasicTransform>;
+    }[]
+  ) {
+
+    const compoundShape = CompoundShape.create({ shapes: { pool: this.pools.transformedShape } }, this.pools.compoundShape);
+
+    compoundShape.world = this;
+
+    for (const param of params) {
+      const transformedShape = compoundShape.shapes.create(
+        {
+          transform: param.transform,
+        },
+      );
+      transformedShape.shape = param.shape;
+    }
+
+    compoundShape.update();
+
+    const compoundShapeCopy = CompoundShape.create({ shapes: { pool: this.pools.transformedShape } }, this.pools.compoundShapeCopy);
+    compoundShapeCopy.copy(compoundShape);
+    compoundShape.copyForDiff = compoundShapeCopy;
+    compoundShapeCopy.update();
+
+    return compoundShape;
+  }
+
+  /**
+   * Creates a height map shape from the given resolution, extents, and heights.
+   * @param resolution - The number of vertices in each dimension of the height map.
+   * @param extents - The width, height, and depth of the height map in meters.
+   * @param heights - A flat array of heights for each vertex in the height map. normalized to the range [0, 1]
+   */
+  createHeightMap(
+    vertexCount: { width: number; depth: number },
+    extents: InputType<Vec3>,
+    heights: Float32Array | Float64Array | number[]
+  ) {
+    const shape = this.heightMapBuilder.buildHeightMap(vertexCount, extents, heights, this.pools.heightMap);
+
+    // TODO: should we implement copyForDiff for heightmap?
+    // const shapeCopy = this.heightMapBuilder.buildHeightMap(subdivisionsCount, scale, positionOffset, heights);
+    // shapeCopy.copy(shape);
+    // shape.copyForDiff = shapeCopy;
+
+    shape.world = this;
+    return shape;
+  }
+
+  *bodies() {
+    yield* this.dynamicBodies;
+    yield* this.kinematicBodies;
+    yield* this.staticBodies;
+  }
+
+  destroyShape(shape: Shape) {
+    for (const body of this.bodies()) {
+      if (body.shape === shape) {
+        body.destroy();
+      }
+    }
+
+    const shapeCopy = shape.copyForDiff;
+    if (shapeCopy) {
+      shapeCopy.destroy();
+    }
+
+    shape.destroy();
+  }
+
+  // bodies API
+  createStaticBody(options: InputType<Body> & { shape: StaticShape }): Body {
+    options = options ?? {};
+    options.type = BodyType.static;
+    const body = this.staticBodies.create(options);
+
+    const bodyCopy = this.staticBodyCopies.create(options);
+    bodyCopy.copy(body);
+    body.copyForDiff = bodyCopy;
+
+    body.world = this;
+
+    this.broadphase.addStaticBody(body);
+    return body;
+  }
+
+  createDynamicBody(options: InputType<Body> & { shape: DynamicShape }): Body {
+    options = options ?? {};
+    options.type = BodyType.dynamic;
+    const body = this.dynamicBodies.create(options);
+
+    const bodyCopy = this.dynamicBodyCopies.create(options);
+    bodyCopy.copy(body);
+    body.copyForDiff = bodyCopy;
+
+    body.world = this;
+
+    this.broadphase.addDynamicBody(body);
+    return body;
+  }
+
+  createKinematicBody(options: InputType<Body> & { shape: KinematicShape }): Body {
+    options = options ?? {};
+    options.type = BodyType.kinematic;
+    const body = this.kinematicBodies.create(options);
+
+    const bodyCopy = this.kinematicBodyCopies.create(options);
+    bodyCopy.copy(body);
+    body.copyForDiff = bodyCopy;
+
+    body.world = this;
+
+    this.broadphase.addKinematicBody(body);
+    return body;
+  }
+
+  createBody(
+    options: InputType<Body> &
+      (
+        | { type: BodyType.dynamic; shape: DynamicShape }
+        | { type: BodyType.static; shape: StaticShape }
+        | { type: BodyType.kinematic; shape: KinematicShape }
+      )
+  ) {
+    switch (options.type) {
+      case BodyType.dynamic: {
+        return this.createDynamicBody(options);
+      }
+
+      case BodyType.static: {
+        return this.createStaticBody(options);
+      }
+
+      case BodyType.kinematic: {
+        return this.createKinematicBody(options);
+      }
+
+      default: {
+        throw new Error(`Unknown options: ${options}`);
+      }
+    }
+  }
+
+  destroyBody(body: Body) {
+    const bodyCopy = body.copyForDiff;
+    if (bodyCopy) {
+      bodyCopy.destroy();
+    }
+
+    switch (body.type) {
+      case BodyType.dynamic: {
+        this.broadphase.removeDynamicBody(body as WithPool<Body>);
+        break;
+      }
+
+      case BodyType.static: {
+        this.broadphase.removeStaticBody(body as WithPool<Body>);
+        break;
+      }
+
+      case BodyType.kinematic: {
+        this.broadphase.removeKinematicBody(body as WithPool<Body>);
+        break;
+      }
+
+      default: {
+        throw new Error("Unknown body type.");
+      }
+    }
+
+    this.constraintSolver.constraintPairs.destroyAllPairsOfOne(body);
+
+    body.node = null;
+    body.destroy();
+  }
+
+  // contacts API
+  didBodiesCollide(bodyA: Body, bodyB: Body) {
+    const cache = this.collideBodiesModule.contactManifoldModule.currentManifoldCache;
+    const key = createContactPairKey(bodyA, bodyB);
+    return cache.pairMap.has(key);
+  }
+
+  *iterateContactManifolds(bodyA?: Body, bodyB?: Body) {
+    const cache = this.collideBodiesModule.contactManifoldModule.currentManifoldCache;
+
+    if (!bodyA && !bodyB) {
+      for (const manifold of cache.manifolds.contactManifoldPool) {
+        yield manifold;
+      }
+    } else if (bodyA && !bodyB) {
+      for (const manifold of cache.manifolds.contactManifoldPool) {
+        if (manifold.containsBody(bodyA)) {
+          yield manifold;
+        }
+      }
+    } else if (!bodyA && bodyB) {
+      for (const manifold of cache.manifolds.contactManifoldPool) {
+        if (manifold.containsBody(bodyB)) {
+          yield manifold;
+        }
+      }
+    } else {
+      const key = createContactPairKey(bodyA!, bodyB!);
+      const pair = cache.pairMap.get(key);
+      if (!pair) {
+        return;
+      }
+
+      let manifold = pair.firstContactManifold;
+      while (manifold) {
+        yield manifold;
+        manifold = manifold.nextContactManifold as WithPool<ContactManifold> | null;
+      }
+    }
+  }
+
+  // scene query API
+  intersectShape(
+    onHit: (result: CollisionResult) => boolean,
+    shape: Shape,
+    transform: BasicTransform,
+    settings?: ShapeIntersectSettings
+  ) {
+    settings = settings || { precision: QueryPrecision.preciseWithContacts, returnClosestOnly: true };
+    isometry.fromRotationAndTranslation(transform.rotation, transform.position);
+    intersectShapeCollector.initialize(onHit);
+    this.collideBodiesModule.collideShape(
+      shape,
+      1.0,
+      isometry,
+      intersectShapeCollector,
+      collideShapeSettings,
+      zeroVector,
+      AllFlag
+    );
+  }
+
+  castRay(onHit: (result: CastRayResult) => boolean, ray: Ray, settings?: RayCastSettings) {
+    settings = settings || { precision: QueryPrecision.preciseWithContacts, returnClosestOnly: true };
+    this.collideBodiesModule.castRay(onHit, ray, settings, AllFlag, AllFlag);
+  }
+
+  castShape(
+    onHit: (result: CastShapeResult) => boolean,
+    shape: Shape,
+    transform: BasicTransform,
+    displacementOrEndPosition: Vec3,
+    settings?: ShapeCastSettings
+  ) {
+    isometry.fromRotationAndTranslation(transform.rotation, transform.position);
+    settings = settings || {
+      precision: QueryPrecision.preciseWithContacts,
+      returnClosestOnly: false,
+      treatAsDisplacement: false,
+    };
+    if (settings.treatAsDisplacement) {
+      displacement.copy(displacementOrEndPosition);
+    } else {
+      displacement.zero();
+      displacement.subtractVectors(displacementOrEndPosition, transform.position);
+    }
+    castShapeCollector.initialize(onHit);
+    this.collideBodiesModule.castShape(
+      shape,
+      1.0,
+      isometry,
+      displacement,
+      castSettings,
+      zeroVector,
+      castShapeCollector,
+      AllFlag
+    );
+  }
+
+  estimateCollisionResponse(
+    result: EstimateCollisionResponseResult,
+    bodyA: Body,
+    bodyB: Body,
+    settings?: Partial<EstimateCollisionResponseSettings>
+  ) {
+    const timeStepSizeSeconds = settings?.timeStepSizeSeconds ?? this.options.timeStepSizeSeconds;
+    this.collideBodiesModule.estimateCollisionResponse(result, bodyA, bodyB, timeStepSizeSeconds);
+  }
+
+  // serialization API
+  toArray(array: number[] | Float32Array | Float64Array, startOffset = 0): number {
+    // order needs to match fromArray!
+
+    // shapes
+    startOffset = this.pools.boxCopy.toArray(array, startOffset);
+    startOffset = this.pools.box.toArray(array, startOffset);
+
+    startOffset = this.pools.capsuleCopy.toArray(array, startOffset);
+    startOffset = this.pools.capsule.toArray(array, startOffset);
+
+    startOffset = this.pools.cylinderCopy.toArray(array, startOffset);
+    startOffset = this.pools.cylinder.toArray(array, startOffset);
+
+    startOffset = this.pools.sphereCopy.toArray(array, startOffset);
+    startOffset = this.pools.sphere.toArray(array, startOffset);
+
+    startOffset = this.pools.convexHullFace.toArray(array, startOffset);
+    startOffset = this.pools.convexHullNumberValue.toArray(array, startOffset);
+    startOffset = this.pools.convexHullPlane.toArray(array, startOffset);
+    startOffset = this.pools.convexHullPoint.toArray(array, startOffset);
+    startOffset = this.pools.convexHullVec3.toArray(array, startOffset);
+    startOffset = this.pools.convexHullCopy.toArray(array, startOffset);
+    startOffset = this.pools.convexHull.toArray(array, startOffset);
+
+    startOffset = this.pools.triangleMeshBvhNode.toArray(array, startOffset);
+    startOffset = this.pools.triangleMeshBvhTree.toArray(array, startOffset);
+    startOffset = this.pools.triangleMeshVertexPosition.toArray(array, startOffset);
+    startOffset = this.pools.triangleMeshFaceIndex.toArray(array, startOffset);
+    startOffset = this.pools.triangleMeshTriangle.toArray(array, startOffset);
+    startOffset = this.pools.triangleMeshCopy.toArray(array, startOffset);
+    startOffset = this.pools.triangleMesh.toArray(array, startOffset);
+
+    startOffset = this.pools.heightMapCopy.toArray(array, startOffset);
+    startOffset = this.pools.heightMap.toArray(array, startOffset);
+
+    startOffset = this.pools.transformedShape.toArray(array, startOffset);
+    startOffset = this.pools.compoundShapeCopy.toArray(array, startOffset);
+    startOffset = this.pools.compoundShape.toArray(array, startOffset);
+
+    // bodies
+    startOffset = this.pools.bodyCopy.toArray(array, startOffset);
+    startOffset = this.pools.body.toArray(array, startOffset);
+
+    // constraints
+    startOffset = this.pools.constraintPairNode.toArray(array, startOffset);
+    startOffset = this.pools.constraintPairEdge.toArray(array, startOffset);
+
+    startOffset = this.constraintSolver.distanceConstraints.toArray(array, startOffset);
+    startOffset = this.constraintSolver.fixedConstraints.toArray(array, startOffset);
+    startOffset = this.constraintSolver.hingeConstraints.toArray(array, startOffset);
+    startOffset = this.constraintSolver.pointConstraints.toArray(array, startOffset);
+
+    // bvh
+    startOffset = this.broadphase.toArray(array, startOffset);
+
+    // contact manifold cache
+    startOffset = this.collideBodiesModule.contactManifoldModule.toArray(array, startOffset);
+
+    return startOffset;
+  }
+
+  fromArray(array: number[] | Float32Array | Float64Array, startOffset = 0): number {
+    startOffset = this.pools.boxCopy.fromArray(array, { copyForDiff: null! }, startOffset);
+    startOffset = this.pools.box.fromArray(array, { copyForDiff: this.pools.boxCopy }, startOffset);
+
+    startOffset = this.pools.capsuleCopy.fromArray(array, { copyForDiff: null! }, startOffset);
+    startOffset = this.pools.capsule.fromArray(array, { copyForDiff: this.pools.capsuleCopy }, startOffset);
+
+    startOffset = this.pools.cylinderCopy.fromArray(array, { copyForDiff: null! }, startOffset);
+    startOffset = this.pools.cylinder.fromArray(array, { copyForDiff: this.pools.cylinderCopy }, startOffset);
+
+    startOffset = this.pools.sphereCopy.fromArray(array, { copyForDiff: null! }, startOffset);
+    startOffset = this.pools.sphere.fromArray(array, { copyForDiff: this.pools.sphereCopy }, startOffset);
+
+    startOffset = this.pools.convexHullFace.fromArray(array, startOffset);
+    startOffset = this.pools.convexHullNumberValue.fromArray(array, startOffset);
+    startOffset = this.pools.convexHullPlane.fromArray(array, startOffset);
+    startOffset = this.pools.convexHullPoint.fromArray(array, startOffset);
+    startOffset = this.pools.convexHullVec3.fromArray(array, startOffset);
+    startOffset = this.pools.convexHullCopy.fromArray(array, {
+      copyForDiff: null!,
+      faces: this.pools.convexHullFace,
+      planes: this.pools.convexHullPlane,
+      points: this.pools.convexHullPoint,
+      shapeNoConvexPoints: this.pools.convexHullVec3,
+      vertexIdx: this.pools.convexHullNumberValue,
+    }, startOffset);
+    startOffset = this.pools.convexHull.fromArray(array, {
+      copyForDiff: this.pools.convexHullCopy,
+      faces: this.pools.convexHullFace,
+      planes: this.pools.convexHullPlane,
+      points: this.pools.convexHullPoint,
+      shapeNoConvexPoints: this.pools.convexHullVec3,
+      vertexIdx: this.pools.convexHullNumberValue
+    }, startOffset);
+
+    startOffset = this.pools.triangleMeshBvhNode.fromArray(array, {
+      left: this.pools.triangleMeshBvhNode,
+      right: this.pools.triangleMeshBvhNode,
+      parent: this.pools.triangleMeshBvhNode,
+      objects: this.pools.triangleMeshTriangle,
+    }, startOffset);
+    startOffset = this.pools.triangleMeshBvhTree.fromArray(array, {
+      nodes: this.pools.triangleMeshBvhNode,
+    }, startOffset);
+    startOffset = this.pools.triangleMeshVertexPosition.fromArray(array, startOffset);
+    startOffset = this.pools.triangleMeshFaceIndex.fromArray(array, startOffset);
+    startOffset = this.pools.triangleMeshTriangle.fromArray(array, startOffset);
+    startOffset = this.pools.triangleMeshCopy.fromArray(array, {
+      copyForDiff: null!,
+      bvh: this.pools.triangleMeshBvhTree,
+      vertexPositions: this.pools.triangleMeshVertexPosition,
+      faceIndices: this.pools.triangleMeshFaceIndex,
+      triangles: this.pools.triangleMeshTriangle,
+    }, startOffset);
+    startOffset = this.pools.triangleMesh.fromArray(array, {
+      copyForDiff: this.pools.triangleMeshCopy,
+      bvh: this.pools.triangleMeshBvhTree,
+      vertexPositions: this.pools.triangleMeshVertexPosition,
+      faceIndices: this.pools.triangleMeshFaceIndex,
+      triangles: this.pools.triangleMeshTriangle,
+    }, startOffset);
+
+    startOffset = this.pools.heightMapCopy.fromArray(array, { copyForDiff: null! }, startOffset);
+    startOffset = this.pools.heightMap.fromArray(array, { copyForDiff: this.pools.heightMapCopy }, startOffset);
+
+    startOffset = this.pools.transformedShape.fromArray(array, {
+      shape0: this.pools.box,
+      shape1: this.pools.capsule,
+      shape3: this.pools.convexHull,
+      shape4: this.pools.cylinder,
+      shape6: this.pools.sphere,
+    }, startOffset);
+    startOffset = this.pools.compoundShapeCopy.fromArray(
+      array,
+      {
+        copyForDiff: null!,
+        shapes: this.pools.transformedShape,
+      },
+      startOffset,
+    );
+    startOffset = this.pools.compoundShape.fromArray(
+      array,
+      {
+        copyForDiff: this.pools.compoundShapeCopy,
+        shapes: this.pools.transformedShape,
+      },
+      startOffset,
+    );
+
+    let startOffsetConstraintPairNode, startOffsetBody, startOffsetBodyCopy, startOffsetBodyPairNode;
+
+    startOffsetBodyCopy = startOffset;
+    startOffset = this.pools.bodyCopy.fromArrayNoReferences(array, startOffset);
+    startOffsetBody = startOffset;
+    startOffset = this.pools.body.fromArrayNoReferences(array, startOffset);
+
+    startOffsetConstraintPairNode = startOffset;
+    startOffset = this.pools.constraintPairNode.fromArrayNoReferences(array, startOffset);
+    this.pools.constraintPairEdge.fromArrayNoReferences(array, startOffset);
+    startOffset = this.pools.constraintPairEdge.fromArrayOnlyReferences(array, {
+      node: this.pools.constraintPairNode,
+      next: this.pools.constraintPairEdge,
+      prev: this.pools.constraintPairEdge,
+    }, startOffset);
+
+    startOffset = this.constraintSolver.distanceConstraints.fromArray(array, {
+      bodyA: this.pools.body,
+      bodyB: this.pools.body,
+      constraintPairNode: this.pools.constraintPairNode,
+    }, startOffset);
+    startOffset = this.constraintSolver.fixedConstraints.fromArray(array, {
+      bodyA: this.pools.body,
+      bodyB: this.pools.body,
+      constraintPairNode: this.pools.constraintPairNode,
+    }, startOffset);
+    startOffset = this.constraintSolver.hingeConstraints.fromArray(array, {
+      bodyA: this.pools.body,
+      bodyB: this.pools.body,
+      constraintPairNode: this.pools.constraintPairNode,
+    }, startOffset);
+    startOffset = this.constraintSolver.pointConstraints.fromArray(array, {
+      bodyA: this.pools.body,
+      bodyB: this.pools.body,
+      constraintPairNode: this.pools.constraintPairNode,
+    }, startOffset);
+
+
+    startOffset = this.broadphase.fromArray(array, startOffset);
+
+
+    this.pools.constraintPairNode.fromArrayOnlyReferences(array, {
+      bodyA: this.pools.body,
+      bodyB: this.pools.body,
+      edgeA: this.pools.constraintPairEdge,
+      edgeB: this.pools.constraintPairEdge,
+      constraintDistance: this.constraintSolver.distanceConstraints,
+      constraintFixed: this.constraintSolver.fixedConstraints,
+      constraintHinge: this.constraintSolver.hingeConstraints,
+      constraintPoint: this.constraintSolver.pointConstraints,
+    }, startOffsetConstraintPairNode);
+
+    this.pools.bodyCopy.fromArrayOnlyReferences(array, {
+      copyForDiff: null!,
+      firstPotentialConstraintPairEdge: this.pools.constraintPairEdge,
+      node: this.pools.bvhNodes,
+      firstPotentialPairEdge: this.pools.bodyPairEdge,
+      ['shape' + ShapeType.box as 'shape0']: this.pools.box,
+      ['shape' + ShapeType.capsule as 'shape1']: this.pools.capsule,
+      ['shape' + ShapeType.compoundShape as 'shape2']: this.pools.compoundShape,
+      ['shape' + ShapeType.convexHull as 'shape3']: this.pools.convexHull,
+      ['shape' + ShapeType.cylinder as 'shape4']: this.pools.cylinder,
+      ['shape' + ShapeType.heightMap as 'shape5']: this.pools.heightMap,
+      ['shape' + ShapeType.sphere as 'shape6']: this.pools.sphere,
+      ['shape' + ShapeType.triangleMesh as 'shape7']: this.pools.triangleMesh,
+    }, startOffsetBodyCopy);
+
+    this.pools.body.fromArrayOnlyReferences(array, {
+      copyForDiff: this.pools.bodyCopy,
+      firstPotentialConstraintPairEdge: this.pools.constraintPairEdge,
+      node: this.pools.bvhNodes,
+      firstPotentialPairEdge: this.pools.bodyPairEdge,
+      ['shape' + ShapeType.box as 'shape0']: this.pools.box,
+      ['shape' + ShapeType.capsule as 'shape1']: this.pools.capsule,
+      ['shape' + ShapeType.compoundShape as 'shape2']: this.pools.compoundShape,
+      ['shape' + ShapeType.convexHull as 'shape3']: this.pools.convexHull,
+      ['shape' + ShapeType.cylinder as 'shape4']: this.pools.cylinder,
+      ['shape' + ShapeType.heightMap as 'shape5']: this.pools.heightMap,
+      ['shape' + ShapeType.sphere as 'shape6']: this.pools.sphere,
+      ['shape' + ShapeType.triangleMesh as 'shape7']: this.pools.triangleMesh,
+    }, startOffsetBody);
+
+    startOffset = this.collideBodiesModule.contactManifoldModule.fromArray(array, {
+      body: this.pools.body,
+    }, startOffset);
+
+    return startOffset;
+  }
+
+  // constraints
+  createPointConstraint(params: InputType<PointConstraint>) {
+    return this.constraintSolver.createPointConstraint(params);
+  }
+
+  createFixedConstraint(params: InputType<FixedConstraint>) {
+    return this.constraintSolver.createFixedConstraint(params);
+  }
+
+  createDistanceConstraint(params: InputType<DistanceConstraint>) {
+    return this.constraintSolver.createDistanceConstraint(params);
+  }
+
+  createHingeConstraint(params: InputType<HingeConstraint>) {
+    return this.constraintSolver.createHingeConstraint(params);
+  }
+
+  destroyConstraint(constraint: Constraint) {
+    this.constraintSolver.destroyConstraint(constraint);
+  }
+}
+
+const isometry = /*@__PURE__*/ Isometry.create();
+const collideShapeSettings: CollisionSettings = {
+  activeEdgeMode: ActiveEdgeMode.CollideWithAll,
+  activeEdgeMovementDirectionX: 0,
+  activeEdgeMovementDirectionY: 0,
+  activeEdgeMovementDirectionZ: 0,
+  backFaceMode: BackFaceMode.IgnoreBackFaces,
+  collectFacesMode: CollectFacesMode.NoFaces,
+  collisionTolerance: 1e-4,
+  maxSeparation: 0.02,
+  penetrationTolerance: 1e-4,
+};
+const zeroVector = /*@__PURE__*/ Vec3.create();
+
+interface ShapeIntersectSettings {
+  precision?: QueryPrecision;
+  returnClosestOnly?: boolean;
+}
+
+interface ShapeCastSettings {
+  precision?: QueryPrecision;
+  returnClosestOnly?: boolean;
+  treatAsDisplacement?: boolean;
+}
+
+interface EstimateCollisionResponseSettings {
+  timeStepSizeSeconds: number;
+}
+
+interface CastShapeResult {}
+
+class IntersectShapeCollector extends CollisionCollector {
+  onHit: ((result: CollisionResult) => boolean) | null = null;
+
+  initialize(onHit: (result: CollisionResult) => boolean) {
+    this.onHit = onHit;
+  }
+
+  addHit(result: CollisionResult): void {
+    this.onHit?.(result);
+  }
+}
+const intersectShapeCollector = /*@__PURE__*/ new IntersectShapeCollector();
+const displacement = /*@__PURE__*/ Vec3.create();
+const castSettings = /*@__PURE__*/ createDefaultCastSettings();
+
+class CastShapeCollector extends CastCollector {
+  onHit: ((result: CastShapeResult) => boolean) | null = null;
+
+  initialize(onHit: (result: CastShapeResult) => boolean) {
+    this.onHit = onHit;
+  }
+
+  addHit(result: CastShapeResult): void {
+    this.onHit?.(result);
+  }
+}
+const castShapeCollector = /*@__PURE__*/ new CastShapeCollector();