@perplexdotgg/bounce 1.0.0

package/src/collision/collide/collideCompoundVsHeightMap.ts

@@ -0,0 +1,73 @@
+import { Isometry } from "../../math/isometry";
+import { Vec3 } from "../../math/vec3";
+import { Aabb } from "../../shape/Aabb";
+import { CompoundShape } from "../../shape/CompoundShape";
+import { HeightMap } from "../../shape/HeightMap";
+import { PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { BackFaceMode, CollisionCollector, CollisionSettings } from "./collide";
+import { HeightMapCollider } from "../HeightMapCollider";
+import { Body } from "../../physics/Body";
+import { BasicTransform, ConvexShape } from "../..";
+
+const isometryWorldToB = /*@__PURE__*/ Isometry.create();
+const isometryAToB = /*@__PURE__*/ Isometry.create();
+const shapeABoundsInBSpace = /*@__PURE__*/ Aabb.create();
+
+const transformSubShapeToA = /*@__PURE__*/ Isometry.create();
+const transformSubShapeToWorld = /*@__PURE__*/ Isometry.create();
+
+const heightMapCollider = /*@__PURE__*/ new HeightMapCollider();
+
+export function collideCompoundVsHeightMap(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: CompoundShape,
+  shapeB: HeightMap,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+) {
+  // TODO: don't hardcode this option
+  settings.backFaceMode = BackFaceMode.CollideWithBackFaces;
+
+  let index = 0;
+  for (const shapeObj of shapeA.shapes) {
+    const shape = shapeObj.shape as ConvexShape;
+    const transform = shapeObj.transform as BasicTransform;
+    const translation = transform.position;
+    const rotation = transform.rotation;
+
+    // set the isometries
+    transformSubShapeToA.fromRotationAndTranslation(rotation, translation);
+    transformSubShapeToWorld.matrix.multiplyMatrices(isometryA.matrix, transformSubShapeToA.matrix);
+
+    heightMapCollider.triangleCollider.initialize(
+      penetrationDepthModule,
+      shape,
+      transformSubShapeToWorld,
+      isometryB,
+      settings,
+      collector,
+      index,
+      bodyA,
+      bodyB
+    );
+
+    isometryWorldToB.matrix.invertMatrix(isometryB.matrix);
+
+    isometryAToB.matrix.multiplyMatrices(transformSubShapeToWorld.matrix, isometryWorldToB.matrix);
+
+    shapeABoundsInBSpace.copy(shape.computedAabb);
+    shapeABoundsInBSpace.transform(isometryAToB);
+    shapeABoundsInBSpace.expand(settings.maxSeparation);
+    heightMapCollider.initialize(shapeABoundsInBSpace, bodyA, bodyB);
+    shapeB.walkHeightMap(heightMapCollider);
+
+    index++;
+  }
+}

package/src/collision/collide/collideCompoundVsTriangleMesh.ts

@@ -0,0 +1,56 @@
+import { Isometry } from "../../math/isometry";
+import { Vec3 } from "../../math/vec3";
+import { PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { CollisionCollector, CollisionSettings } from "./collide";
+import { CompoundShape } from "../../shape/CompoundShape";
+import { TriangleMesh } from "../../shape/TriangleMesh";
+import { collideConvexVsTriangleMesh } from "./collideConvexVsTriangleMesh";
+import { Body } from "../../physics/Body";
+import { ConvexShape } from "../..";
+
+const transformSubShapeToA = /*@__PURE__*/ Isometry.create();
+const transformSubShapeToWorld = /*@__PURE__*/ Isometry.create();
+
+// the results are in world space
+export function collideCompoundVsTriangleMesh(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: CompoundShape,
+  shapeB: TriangleMesh,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+): void {
+  let index = 0;
+  for (const { shape, transform } of shapeA.shapes) {
+    const translation = transform.position;
+    const rotation = transform.rotation;
+
+    // set the isometries
+    transformSubShapeToA.fromRotationAndTranslation(rotation, translation);
+    transformSubShapeToWorld.matrix.multiplyMatrices(isometryA.matrix, transformSubShapeToA.matrix);
+
+    // collide the shapes. TODO: this should be convex vs convex for now, but may be expanded in the future
+    collideConvexVsTriangleMesh(
+      penetrationDepthModule,
+      collector,
+      shape as ConvexShape,
+      shapeB,
+      transformSubShapeToWorld,
+      isometryB,
+      settings,
+      bodyA,
+      bodyB,
+      initialDirection,
+      index,
+      0
+    );
+
+    index++;
+  }
+}

package/src/collision/collide/collideConvexVsCompound.ts

@@ -0,0 +1,57 @@
+import { Isometry } from "../../math/isometry";
+import { Vec3 } from "../../math/vec3";
+import { PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { CollisionCollector, CollisionSettings } from "./collide";
+import { CompoundShape } from "../../shape/CompoundShape";
+import { collideConvexVsConvex } from "./collideConvexVsConvex";
+import { Body } from "../../physics/Body";
+import { ConvexShape } from "../../shape/Shape";
+
+const transformSubShapeBToB = /*@__PURE__*/ Isometry.create();
+const transformSubShapeBToWorld = /*@__PURE__*/ Isometry.create();
+
+// the results are in world space
+export function collideConvexVsCompound(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: ConvexShape,
+  shapeB: CompoundShape,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+): void {
+  // throw new Error("Not implemented");
+
+  let index = 0;
+  for (const { shape: subShapeB, transform } of shapeB.shapes) {
+    const translation = transform.position;
+    const rotation = transform.rotation;
+
+    // set the isometries
+    transformSubShapeBToB.fromRotationAndTranslation(rotation, translation);
+    transformSubShapeBToWorld.matrix.multiplyMatrices(isometryB.matrix, transformSubShapeBToB.matrix);
+
+    // collide the shapes. TODO: this should be convex vs convex for now, but may be expanded in the future
+    collideConvexVsConvex(
+      penetrationDepthModule,
+      collector,
+      shapeA,
+      subShapeB as ConvexShape,
+      isometryA,
+      transformSubShapeBToWorld,
+      settings,
+      bodyA,
+      bodyB,
+      initialDirection,
+      0,
+      index
+    );
+
+    index++;
+  }
+}

package/src/collision/collide/collideConvexVsConvex.ts

@@ -0,0 +1,225 @@
+import { Isometry } from "../../math/isometry";
+import { Vec3 } from "../../math/vec3";
+import { Face } from "../../physics/manifold/Face";
+import { PenetrationDepth, PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { CollisionCollector, CollisionResult, CollisionSettings, CollisionStatus } from "./collide";
+import {
+  ConvexRadiusObject,
+  ConvexWithcomputeSupportShape,
+  SupportMode,
+  TransformedConvexShape,
+} from "../../shape/Convex";
+import { Body } from "../../physics/Body";
+
+const result = CollisionResult.create({
+  faceA: {
+    numVertices: 0,
+    buffer: { pool: new Vec3.Pool(32), maxLength: 32 },
+  },
+  faceB: {
+    numVertices: 0,
+    buffer: { pool: new Vec3.Pool(32), maxLength: 32 },
+  },
+});
+
+const positionA = /*@__PURE__*/ Vec3.create();
+const positionB = /*@__PURE__*/ Vec3.create();
+const searchDirection = /*@__PURE__*/ Vec3.create();
+const gjkResult = /*@__PURE__*/ PenetrationDepth.create();
+const ab = /*@__PURE__*/ Vec3.create();
+const transformedShapeA = /*@__PURE__*/ TransformedConvexShape.create();
+const transformedShapeB = /*@__PURE__*/ TransformedConvexShape.create();
+const convexObjectA = /*@__PURE__*/ ConvexRadiusObject.create();
+const vectorAB = /*@__PURE__*/ Vec3.create();
+
+const inverseIsometryA = /*@__PURE__*/ Isometry.create();
+const isometryBToA = /*@__PURE__*/ Isometry.create();
+
+const pointAB = /*@__PURE__*/ Vec3.create();
+const penetrationAxisWorld = /*@__PURE__*/ Vec3.create();
+
+// the results are in world space
+export function collideConvexVsConvex(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: ConvexWithcomputeSupportShape,
+  shapeB: ConvexWithcomputeSupportShape,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+): void {
+  result.reset();
+  // @ts-ignore
+  result.bodyA = bodyA;
+  // @ts-ignore
+  result.bodyB = bodyB;
+  collector.body2 = bodyB;
+
+  // get support functions that exclude convex radii
+  const shapeAExcludingConvexRadius = shapeA.computeSupportShape(SupportMode.ExcludeConvexRadius, 1);
+  const shapeBExcludingConvexRadius = shapeB.computeSupportShape(SupportMode.ExcludeConvexRadius, 1);
+
+  // get convex radii, including the max separation distance
+  const convexRadiusA = shapeAExcludingConvexRadius.getConvexRadius() + settings.maxSeparation;
+  const convexRadiusB = shapeBExcludingConvexRadius.getConvexRadius();
+
+  // create transformed convex objects
+  transformedShapeA.transform.matrix.identity();
+  transformedShapeA.object = shapeAExcludingConvexRadius;
+
+  inverseIsometryA.matrix.invertMatrix(isometryA.matrix);
+  isometryBToA.matrix.multiplyMatrices(inverseIsometryA.matrix, isometryB.matrix);
+
+  isometryA.matrix.getTranslation(positionA);
+  isometryBToA.matrix.getTranslation(positionB);
+  vectorAB.subtractVectors(positionB, positionA);
+  searchDirection.copy(vectorAB).normalize();
+  if (searchDirection.isNearZero()) {
+    searchDirection.fromArray([0, -1, 0]);
+  }
+
+  // transformedShapeB.transform.matrix.copy(isometryB.matrix);
+  transformedShapeB.transform.matrix.copy(isometryBToA.matrix);
+  transformedShapeB.object = shapeBExcludingConvexRadius;
+
+  // collide shapes using GJK
+  penetrationDepthModule.getPenetrationDepthStepGjk(
+    gjkResult,
+    transformedShapeA,
+    transformedShapeB,
+    convexRadiusA,
+    convexRadiusB,
+    searchDirection,
+    settings.collisionTolerance
+  );
+
+  switch (gjkResult.status) {
+    case CollisionStatus.Colliding: {
+      const point1 = gjkResult.pointA;
+      const point2 = gjkResult.pointB;
+      const penetration_axis = gjkResult.penetrationAxis;
+
+      // check if penetration is bigger than early out fraction
+      pointAB.subtractVectors(point2, point1);
+      const penetration_depth = pointAB.length() - settings.maxSeparation;
+      if (-penetration_depth >= collector.getEarlyOutFraction()) {
+        result.hasContact = false;
+        collector.addMiss();
+        return;
+      }
+
+      // correct pointA for the added separation distance
+      const penetration_axis_len = penetration_axis.length();
+      if (penetration_axis_len > 0.0) {
+        point1.addScaled(penetration_axis, -(settings.maxSeparation / penetration_axis_len));
+      }
+
+      // convert to world space
+      point1.transformByMat4(isometryA.matrix);
+      point2.transformByMat4(isometryA.matrix);
+      isometryA.matrix.multiply3x3(penetrationAxisWorld, penetration_axis);
+
+      // create collision result
+      result.subShapeIdA = subShapeIdA;
+      result.subShapeIdB = subShapeIdB;
+      result.hasContact = true;
+      result.penetration = penetration_depth;
+      result.contactPointA.copy(point1);
+      result.contactPointB.copy(point2);
+      result.normalA.copy(penetrationAxisWorld);
+
+      // TODO: gather faces
+
+      // notify the collector
+      collector.addHit(result);
+      return;
+    }
+
+    case CollisionStatus.NotColliding: {
+      // definitive no penetration
+      result.hasContact = false;
+      collector.addMiss();
+      return;
+    }
+
+    case CollisionStatus.Indeterminate: {
+      // possible deep penetration, use EPA to check
+
+      // get support functions that include convex radii
+      const objectAIncludingConvexRadius = shapeA.computeSupportShape(SupportMode.IncludeConvexRadius, 1);
+      const objectBIncludingConvexRadius = shapeB.computeSupportShape(SupportMode.IncludeConvexRadius, 1);
+
+      // get transformed convex objects
+      transformedShapeA.object = objectAIncludingConvexRadius;
+      transformedShapeB.object = objectBIncludingConvexRadius;
+
+      // add max separation distance to convex object A
+      convexObjectA.setData(settings.maxSeparation, transformedShapeA);
+
+      const hitFound = penetrationDepthModule.getPenetrationDepthStepEPA(
+        convexObjectA,
+        transformedShapeB,
+        settings.penetrationTolerance,
+        penetrationAxis,
+        pointA,
+        pointB
+      );
+
+      if (!hitFound) {
+        // definitive no penetration
+        result.hasContact = false;
+        collector.addMiss();
+        return;
+      }
+
+      // check if penetration is bigger than early out fraction
+      pointAB.subtractVectors(pointB, pointA);
+      const penetration_depth = pointAB.length() - settings.maxSeparation;
+      if (-penetration_depth >= collector.getEarlyOutFraction()) {
+        result.hasContact = false;
+        collector.addMiss();
+        return;
+      }
+
+      // correct pointA for the added separation distance
+      const penetrationAxisLength = penetrationAxis.length();
+      if (penetrationAxisLength > 0.0) {
+        pointA.addScaled(penetrationAxis, -(settings.maxSeparation / penetrationAxisLength));
+      }
+
+      // convert to world space
+      pointA.transformByMat4(isometryA.matrix);
+      pointB.transformByMat4(isometryA.matrix);
+      isometryA.matrix.multiply3x3(penetrationAxisWorld, penetrationAxis);
+
+      // create collision result
+      result.subShapeIdA = subShapeIdA;
+      result.subShapeIdB = subShapeIdB;
+      result.hasContact = true;
+      result.penetration = penetration_depth;
+      result.contactPointA.copy(pointA);
+      result.contactPointB.copy(pointB);
+      result.normalA.copy(penetrationAxisWorld);
+
+      // TODO: gather faces
+
+      // notify the collector
+      collector.addHit(result);
+
+      return;
+    }
+
+    default: {
+      throw new Error(`Invalid status: ${gjkResult.status}`);
+    }
+  }
+}
+
+const penetrationAxis = /*@__PURE__*/ Vec3.create();
+const pointA = /*@__PURE__*/ Vec3.create();
+const pointB = /*@__PURE__*/ Vec3.create();

package/src/collision/collide/collideConvexVsConvexImp.ts

@@ -0,0 +1,236 @@
+import { Isometry } from "../../math/isometry";
+import { Vec3 } from "../../math/vec3";
+import { Face } from "../../physics/manifold/Face";
+import { findContactImp } from "../imp/findContactImp";
+import { ImpResult, ImpStatus } from "../imp/imp";
+import { PenetrationDepth, PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { CollisionCollector, CollisionResult, CollisionSettings, CollisionStatus } from "./collide";
+import {
+  ConvexRadiusObject,
+  ConvexWithcomputeSupportShape,
+  SupportMode,
+  TransformedConvexShape,
+} from "../../shape/Convex";
+import { Body } from "../../physics/Body";
+
+const result = CollisionResult.create({
+  faceA: {
+    numVertices: 0,
+    buffer: { pool: new Vec3.Pool(32), maxLength: 32 },
+  },
+  faceB: {
+    numVertices: 0,
+    buffer: { pool: new Vec3.Pool(32), maxLength: 32 },
+  },
+});
+
+const positionA = /*@__PURE__*/ Vec3.create();
+const positionB = /*@__PURE__*/ Vec3.create();
+const searchDirection = /*@__PURE__*/ Vec3.create();
+const gjkResult = /*@__PURE__*/ PenetrationDepth.create();
+const impResult = /*@__PURE__*/ ImpResult.create();
+const ab = /*@__PURE__*/ Vec3.create();
+const transformedShapeA = /*@__PURE__*/ TransformedConvexShape.create();
+const transformedShapeB = /*@__PURE__*/ TransformedConvexShape.create();
+const convexObjectA = /*@__PURE__*/ ConvexRadiusObject.create();
+const vectorAB = /*@__PURE__*/ Vec3.create();
+
+const inverseIsometryA = /*@__PURE__*/ Isometry.create();
+const isometryBToA = /*@__PURE__*/ Isometry.create();
+
+// the results are in world space
+export function collideConvexVsConvexIMP(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: ConvexWithcomputeSupportShape,
+  shapeB: ConvexWithcomputeSupportShape,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+): void {
+  result.reset();
+  // @ts-ignore
+  result.bodyA = bodyA;
+  // @ts-ignore
+  result.bodyB = bodyB;
+  collector.body2 = bodyB;
+
+  // get support functions that exclude convex radii
+  const shapeAExcludingConvexRadius = shapeA.computeSupportShape(SupportMode.ExcludeConvexRadius, 1);
+  const shapeBExcludingConvexRadius = shapeB.computeSupportShape(SupportMode.ExcludeConvexRadius, 1);
+
+  // get convex radii, including the max separation distance
+  const convexRadiusA = shapeAExcludingConvexRadius.getConvexRadius() + settings.maxSeparation;
+  const convexRadiusB = shapeBExcludingConvexRadius.getConvexRadius();
+
+  // create transformed convex objects
+  transformedShapeA.transform.matrix.identity();
+  transformedShapeA.object = shapeAExcludingConvexRadius;
+
+  inverseIsometryA.matrix.invertMatrix(isometryA.matrix); // world > A
+  isometryBToA.matrix.multiplyMatrices(inverseIsometryA.matrix, isometryB.matrix); // B > A
+
+  isometryA.matrix.getTranslation(positionA);
+  isometryBToA.matrix.getTranslation(positionB);
+  vectorAB.subtractVectors(positionB, positionA); // B > A
+  searchDirection.copy(vectorAB).normalize();
+  if (searchDirection.isNearZero()) {
+    searchDirection.fromArray([0, -1, 0]); // A > B
+  }
+
+  // transformedShapeB.transform.matrix.copy(isometryB.matrix);
+  transformedShapeB.transform.matrix.copy(isometryBToA.matrix);
+  transformedShapeB.object = shapeBExcludingConvexRadius;
+
+  // collide shapes using GJK
+  penetrationDepthModule.getPenetrationDepthStepGjk(
+    gjkResult,
+    transformedShapeA,
+    transformedShapeB,
+    convexRadiusA,
+    convexRadiusB,
+    searchDirection,
+    settings.collisionTolerance
+  );
+
+  switch (gjkResult.status) {
+    case CollisionStatus.Colliding: {
+      // check if penetration is bigger than early out fraction
+      pointAB.subtractVectors(gjkResult.pointB, gjkResult.pointA);
+      const penetrationDepth = pointAB.length() - settings.maxSeparation;
+      if (-penetrationDepth >= collector.getEarlyOutFraction()) {
+        result.hasContact = false;
+        collector.addMiss();
+        return;
+      }
+
+      // correct pointA for the added separation distance
+      const penetrationAxisLength = gjkResult.penetrationAxis.length();
+      if (penetrationAxisLength > 0.0) {
+        gjkResult.pointA.addScaled(gjkResult.penetrationAxis, -(settings.maxSeparation / penetrationAxisLength));
+      }
+
+      // convert to world space
+      gjkResult.pointA.transformByMat4(isometryA.matrix);
+      gjkResult.pointB.transformByMat4(isometryA.matrix);
+      isometryA.matrix.multiply3x3(penetrationAxisWorld, gjkResult.penetrationAxis);
+
+      // create collision result
+      result.subShapeIdA = subShapeIdA;
+      result.subShapeIdB = subShapeIdB;
+      result.hasContact = true;
+      result.penetration = penetrationDepth;
+      result.contactPointA.copy(gjkResult.pointA);
+      result.contactPointB.copy(gjkResult.pointB);
+      result.normalA.copy(penetrationAxisWorld);
+
+      // TODO: gather faces
+
+      // notify the collector
+      collector.addHit(result);
+      return;
+    }
+
+    case CollisionStatus.NotColliding: {
+      // definitive no penetration
+      result.hasContact = false;
+      collector.addMiss();
+      return;
+    }
+
+    case CollisionStatus.Indeterminate: {
+      // possible deep penetration, use IMP to check
+
+      // get support functions that include convex radii
+      const objectAIncludingConvexRadius = shapeA.computeSupportShape(SupportMode.IncludeConvexRadius, 1);
+      const objectBIncludingConvexRadius = shapeB.computeSupportShape(SupportMode.IncludeConvexRadius, 1);
+
+      // get transformed convex objects
+      transformedShapeA.object = objectAIncludingConvexRadius;
+      transformedShapeB.object = objectBIncludingConvexRadius;
+
+      // add max separation distance to convex object A
+      convexObjectA.setData(settings.maxSeparation, transformedShapeA);
+
+      findContactImp(
+        impResult,
+        convexObjectA,
+        transformedShapeB,
+        searchDirection,
+        100,
+        settings.collisionTolerance,
+        false
+      );
+
+      switch (impResult.status) {
+        // TODO: what's the difference between these three?
+        case ImpStatus.DirectedPenetrationFailed:
+        case ImpStatus.Failed:
+        case ImpStatus.FailedNoIntersect: {
+          // definitive no penetration
+          result.hasContact = false;
+          collector.addMiss();
+          return;
+        }
+
+        // TODO: should iteration limit be considered a failure?
+        case ImpStatus.IterationLimit:
+        case ImpStatus.OK: {
+          // check if penetration is bigger than early out fraction
+          pointAB.subtractVectors(impResult.worldContactPointB, impResult.worldContactPointA);
+          const penetrationDepth = pointAB.length() - settings.maxSeparation;
+          if (-penetrationDepth >= collector.getEarlyOutFraction()) {
+            result.hasContact = false;
+            collector.addMiss();
+            return;
+          }
+
+          // correct pointA for the added separation distance
+          const penetrationAxisLength = impResult.penetration_direction.length();
+          if (penetrationAxisLength > 0.0) {
+            impResult.worldContactPointA.addScaled(
+              impResult.penetration_direction,
+              -(settings.maxSeparation / penetrationAxisLength)
+            );
+          }
+
+          // convert to world space
+          impResult.worldContactPointA.transformByMat4(isometryA.matrix);
+          impResult.worldContactPointB.transformByMat4(isometryA.matrix);
+          isometryA.matrix.multiply3x3(penetrationAxisWorld, impResult.penetration_direction);
+
+          // create collision result
+          result.subShapeIdA = subShapeIdA;
+          result.subShapeIdB = subShapeIdB;
+          result.hasContact = true;
+          result.penetration = penetrationDepth;
+          result.contactPointA.copy(impResult.worldContactPointA);
+          result.contactPointB.copy(impResult.worldContactPointB);
+          result.normalA.copy(penetrationAxisWorld);
+
+          // TODO: gather faces
+
+          // notify the collector
+          collector.addHit(result);
+          return;
+        }
+
+        default: {
+          throw new Error(`Invalid status: ${impResult.status}`);
+        }
+      }
+    }
+
+    default: {
+      throw new Error(`Invalid status: ${gjkResult.status}`);
+    }
+  }
+}
+
+const pointAB = /*@__PURE__*/ Vec3.create();
+const penetrationAxisWorld = /*@__PURE__*/ Vec3.create();