@perplexdotgg/bounce 1.0.0 → 1.0.1

package/src/world.ts

@@ -1,1335 +0,0 @@
-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();