@perplexdotgg/bounce 1.0.0

package/src/collision/closestPoints/computeClosestPointOnLine.ts

@@ -0,0 +1,30 @@
+import { Vec3 } from "../../math/vec3";
+import { BarycentricCoordinatesResult, ClosestPointResult } from "./closestPoints";
+import { computeBarycentricCoordinates2d } from "./computeBarycentricCoordinates2d";
+
+const barycentric = /*@__PURE__*/ BarycentricCoordinatesResult.create();
+
+export function computeClosestPointOnLine(
+  outClosestPoints: ClosestPointResult,
+  a: Vec3,
+  b: Vec3,
+  squaredTolerance: number = 1e-10
+) {
+  computeBarycentricCoordinates2d(barycentric, a, b, squaredTolerance);
+
+  if (barycentric.v <= 0.0) {
+    // a is closest point
+    outClosestPoints.point.copy(a);
+    outClosestPoints.pointSet = 0b0001;
+  } else if (barycentric.u <= 0.0) {
+    // b is closest point
+    outClosestPoints.point.copy(b);
+    outClosestPoints.pointSet = 0b0010;
+  } else {
+    // Closest point lies on line ab
+    outClosestPoints.point.zero();
+    outClosestPoints.point.addScaled(a, barycentric.u);
+    outClosestPoints.point.addScaled(b, barycentric.v);
+    outClosestPoints.pointSet = 0b0011;
+  }
+}

package/src/collision/closestPoints/computeClosestPointOnTetrahedron.ts

@@ -0,0 +1,96 @@
+import { Vec3 } from "../../math/vec3";
+import { Vec4 } from "../../math/vec4";
+import { ClosestPointResult } from "./closestPoints";
+import { computeClosestPointOnTriangle } from "./computeClosestPointOnTriangle";
+import { isOriginOutsideOfTrianglePlanes } from "./isOriginOutsideOfTrianglePlanes";
+
+const otherResult = /*@__PURE__*/ ClosestPointResult.create();
+const originOutOfPlanes = /*@__PURE__*/ Vec4.create();
+
+export function computeClosestPointOnTetrahedron(
+  result: ClosestPointResult,
+  inA: Vec3,
+  inB: Vec3,
+  inC: Vec3,
+  inD: Vec3,
+  mustIncludeD: boolean = false,
+  tolerance: number = 1e-5
+): void {
+  const squaredTolerance = tolerance * tolerance;
+
+  // Taken from: Real-Time Collision Detection - Christer Ericson (Section: Closest Point on Tetrahedron to Point)
+  // With p = 0
+
+  // Start out assuming point inside all halfspaces, so closest to itself
+  result.pointSet = 0b1111;
+  result.point.zero();
+
+  let bestDistanceSquared = Infinity;
+
+  // Determine for each of the faces of the tetrahedron if the origin is in front of the plane
+  isOriginOutsideOfTrianglePlanes(originOutOfPlanes, inA, inB, inC, inD, tolerance);
+
+  // If point outside face abc then compute closest point on abc
+  if (originOutOfPlanes.x) {
+    // OriginOutsideOfPlane(inA, inB, inC, inD)
+    if (mustIncludeD) {
+      // If the closest point must include D then ABC cannot be closest but the closest point
+      // cannot be an interior point either so we return A as closest point
+      result.pointSet = 0b0001;
+      result.point.copy(inA);
+    } else {
+      // Test the face normally
+      computeClosestPointOnTriangle(result, inA, inB, inC, false, squaredTolerance);
+    }
+    bestDistanceSquared = result.point.squaredLength();
+  }
+
+  // Repeat test for face acd
+  if (originOutOfPlanes.y) {
+    // OriginOutsideOfPlane(inA, inC, inD, inB)
+    otherResult.pointSet = 0;
+    otherResult.point.zero();
+    computeClosestPointOnTriangle(otherResult, inA, inC, inD, mustIncludeD, squaredTolerance);
+    const distanceSquared = otherResult.point.squaredLength();
+    if (distanceSquared < bestDistanceSquared) {
+      bestDistanceSquared = distanceSquared;
+      result.point.copy(otherResult.point);
+      result.pointSet = (otherResult.pointSet & 0b0001) + ((otherResult.pointSet & 0b0110) << 1);
+    }
+  }
+
+  // Repeat test for face adb
+  if (originOutOfPlanes.z) {
+    // OriginOutsideOfPlane(inA, inD, inB, inC)
+
+    // Keep original vertex order, it doesn't matter if the triangle is facing inward or outward
+    // and it improves consistency for GJK which will always add a new vertex D and keep the closest
+    // feature from the previous iteration in ABC
+    otherResult.pointSet = 0;
+    otherResult.point.zero();
+    computeClosestPointOnTriangle(otherResult, inA, inB, inD, mustIncludeD, squaredTolerance);
+    const distanceSquared = otherResult.point.squaredLength();
+    if (distanceSquared < bestDistanceSquared) {
+      bestDistanceSquared = distanceSquared;
+      result.point.copy(otherResult.point);
+      result.pointSet = (otherResult.pointSet & 0b0011) + ((otherResult.pointSet & 0b0100) << 1);
+    }
+  }
+
+  // Repeat test for face bdc
+  if (originOutOfPlanes.w) {
+    // OriginOutsideOfPlane(inB, inD, inC, inA)
+
+    // Keep original vertex order, it doesn't matter if the triangle is facing inward or outward
+    // and it improves consistency for GJK which will always add a new vertex D and keep the closest
+    // feature from the previous iteration in ABC
+    otherResult.pointSet = 0;
+    otherResult.point.zero();
+    computeClosestPointOnTriangle(otherResult, inB, inC, inD, mustIncludeD, squaredTolerance);
+    const distanceSquared = otherResult.point.squaredLength();
+    if (distanceSquared < bestDistanceSquared) {
+      result.point.copy(otherResult.point);
+      result.pointSet = otherResult.pointSet << 1;
+    }
+  }
+}

package/src/collision/closestPoints/computeClosestPointOnTriangle.ts

@@ -0,0 +1,195 @@
+import { clamp } from "../../math/scalar";
+import { Vec3 } from "../../math/vec3";
+import { ClosestPointResult } from "./closestPoints";
+
+const ac = /*@__PURE__*/ Vec3.create();
+const ab = /*@__PURE__*/ Vec3.create();
+const bc = /*@__PURE__*/ Vec3.create();
+const a = /*@__PURE__*/ Vec3.create();
+const c = /*@__PURE__*/ Vec3.create();
+const n = /*@__PURE__*/ Vec3.create();
+const ap = /*@__PURE__*/ Vec3.create();
+const bp = /*@__PURE__*/ Vec3.create();
+const cp = /*@__PURE__*/ Vec3.create();
+const closestPoint = /*@__PURE__*/ Vec3.create();
+const q = /*@__PURE__*/ Vec3.create();
+const tempVector = /*@__PURE__*/ Vec3.create();
+
+export function computeClosestPointOnTriangle(
+  outClosestPoint: ClosestPointResult,
+  inA: Vec3,
+  inB: Vec3,
+  inC: Vec3,
+  mustIncludeC: boolean = false,
+  squaredTolerance: number = 1e-10
+): void {
+  // Taken from: Real-Time Collision Detection - Christer Ericson (Section: Closest Point on Triangle to Point)
+  // With p = 0
+
+  // The most accurate normal is calculated by using the two shortest edges
+  // See: https://box2d.org/posts/2014/01/troublesome-triangle/
+  // The difference in normals is most pronounced when one edge is much smaller than the others (in which case the other 2 must have roughly the same length).
+  // Therefore we can suffice by just picking the shortest from 2 edges and use that with the 3rd edge to calculate the normal.
+  // We first check which of the edges is shorter and if bc is shorter than ac then we swap a with c to a is always on the shortest edge
+
+  ac.subtractVectors(inC, inA);
+  bc.subtractVectors(inC, inB);
+  const swapAC = bc.dot(bc) < ac.dot(ac);
+
+  a.copy(swapAC ? inC : inA);
+  c.copy(swapAC ? inA : inC);
+
+  // Calculate normal
+  ab.subtractVectors(inB, a);
+  ac.subtractVectors(c, a);
+  n.crossVectors(ab, ac);
+  const normalLengthSquared = n.squaredLength();
+
+  // Check degenerate
+  if (normalLengthSquared < 1.0e-11) {
+    // Square(FLT_EPSILON) was too small and caused numerical problems, see test case TestCollideParallelTriangleVsCapsule
+
+    // Degenerate, fallback to vertices and edges
+
+    // Start with vertex C being the closest
+    let closestSet = 0b0100;
+    closestPoint.copy(inC);
+    let bestDistanceSquared = inC.squaredLength();
+
+    // If the closest point must include C then A or B cannot be closest
+    // Note that we test vertices first because we want to prefer a closest vertex over a closest edge (this results in an outSet with fewer bits set)
+    if (!mustIncludeC) {
+      // Try vertex A
+      const aLengthSquared = inA.squaredLength();
+      if (aLengthSquared < bestDistanceSquared) {
+        closestSet = 0b0001;
+        closestPoint.copy(inA);
+        bestDistanceSquared = aLengthSquared;
+      }
+
+      // Try vertex B
+      const bLengthSquared = inB.squaredLength();
+      if (bLengthSquared < bestDistanceSquared) {
+        closestSet = 0b0010;
+        closestPoint.copy(inB);
+        bestDistanceSquared = bLengthSquared;
+      }
+    }
+
+    // Edge AC
+    const acLengthSquared = ac.squaredLength();
+    if (acLengthSquared > squaredTolerance) {
+      const v = clamp(-a.dot(ac) / acLengthSquared, 0.0, 1.0);
+      q.addScaledToVector(a, ac, v);
+      const distanceSquared = q.squaredLength();
+      if (distanceSquared < bestDistanceSquared) {
+        closestSet = 0b0101;
+        closestPoint.copy(q);
+        bestDistanceSquared = distanceSquared;
+      }
+    }
+
+    // Edge BC
+    bc.subtractVectors(inC, inB);
+    const bcLengthSquared = bc.squaredLength();
+    if (bcLengthSquared > squaredTolerance) {
+      const v = clamp(-inB.dot(bc) / bcLengthSquared, 0.0, 1.0);
+      q.addScaledToVector(inB, bc, v);
+      const distanceSquared = q.squaredLength();
+      if (distanceSquared < bestDistanceSquared) {
+        closestSet = 0b0110;
+        closestPoint.copy(q);
+        bestDistanceSquared = distanceSquared;
+      }
+    }
+
+    // If the closest point must include C then AB cannot be closest
+    if (!mustIncludeC) {
+      // Edge AB
+      ab.subtractVectors(inB, inA);
+      const abLengthSquared = ab.squaredLength();
+      if (abLengthSquared > squaredTolerance) {
+        const v = clamp(-inA.dot(ab) / abLengthSquared, 0.0, 1.0);
+        q.addScaledToVector(inA, ab, v);
+        const distanceSquared = q.squaredLength();
+        if (distanceSquared < bestDistanceSquared) {
+          closestSet = 0b0011;
+          closestPoint.copy(q);
+          bestDistanceSquared = distanceSquared;
+        }
+      }
+    }
+
+    outClosestPoint.pointSet = closestSet;
+    outClosestPoint.point.copy(closestPoint);
+    return;
+  }
+
+  // Check if P in vertex region outside A
+  ap.negateVector(a);
+  const d1 = ab.dot(ap);
+  const d2 = ac.dot(ap);
+  if (d1 <= 0.0 && d2 <= 0.0) {
+    outClosestPoint.pointSet = swapAC ? 0b0100 : 0b0001;
+    outClosestPoint.point.copy(a); // barycentric coordinates (1,0,0)
+    return;
+  }
+
+  // Check if P in vertex region outside B
+  bp.negateVector(inB);
+  const d3 = ab.dot(bp);
+  const d4 = ac.dot(bp);
+  if (d3 >= 0.0 && d4 <= d3) {
+    outClosestPoint.pointSet = 0b0010;
+    outClosestPoint.point.copy(inB); // barycentric coordinates (0,1,0)
+    return;
+  }
+
+  // Check if P in edge region of AB, if so return projection of P onto AB
+  if (d1 * d4 <= d3 * d2 && d1 >= 0.0 && d3 <= 0.0) {
+    const v = d1 / (d1 - d3);
+    outClosestPoint.pointSet = swapAC ? 0b0110 : 0b0011;
+    outClosestPoint.point.addScaledToVector(a, ab, v); // barycentric coordinates (1-v,v,0)
+    return;
+  }
+
+  // Check if P in vertex region outside C
+  cp.negateVector(c);
+  const d5 = ab.dot(cp);
+  const d6 = ac.dot(cp);
+  if (d6 >= 0.0 && d5 <= d6) {
+    outClosestPoint.pointSet = swapAC ? 0b0001 : 0b0100;
+    outClosestPoint.point.copy(c); // barycentric coordinates (0,0,1)
+    return;
+  }
+
+  // Check if P in edge region of AC, if so return projection of P onto AC
+  if (d5 * d2 <= d1 * d6 && d2 >= 0.0 && d6 <= 0.0) {
+    const w = d2 / (d2 - d6);
+    outClosestPoint.pointSet = 0b0101;
+    outClosestPoint.point.addScaledToVector(a, ac, w); // barycentric coordinates (1-w,0,w)
+    return;
+  }
+
+  // Check if P in edge region of BC, if so return projection of P onto BC
+  const diff_d4_d3 = d4 - d3;
+  const diff_d5_d6 = d5 - d6;
+  if (d3 * d6 <= d5 * d4 && diff_d4_d3 >= 0.0 && diff_d5_d6 >= 0.0) {
+    const w = diff_d4_d3 / (diff_d4_d3 + diff_d5_d6);
+    outClosestPoint.pointSet = swapAC ? 0b0011 : 0b0110;
+    tempVector.subtractVectors(c, inB);
+    outClosestPoint.point.addScaledToVector(inB, tempVector, w); // barycentric coordinates (0,1-w,w)
+    return;
+  }
+
+  // P inside face region.
+  // Here we deviate from Christer Ericson's article to improve accuracy.
+  // Determine distance between triangle and origin: distance = (centroid - origin) . normal / |normal|
+  // Closest point to origin is then: distance . normal / |normal|
+  // Note that this way of calculating the closest point is much more accurate than first calculating barycentric coordinates
+  // and then calculating the closest point based on those coordinates.
+  outClosestPoint.pointSet = 0b0111;
+  tempVector.addVectors(a, inB);
+  tempVector.addVectors(tempVector, c);
+  outClosestPoint.point.scaleVector(n, tempVector.dot(n) / (3 * normalLengthSquared));
+}

package/src/collision/closestPoints/isOriginOutsideOfPlane.ts

@@ -0,0 +1,25 @@
+import { Vec3 } from "../../math/vec3";
+
+const n = /*@__PURE__*/ Vec3.create();
+const ab = /*@__PURE__*/ Vec3.create();
+const ac = /*@__PURE__*/ Vec3.create();
+const ad = /*@__PURE__*/ Vec3.create();
+
+export function isOriginOutsideOfPlane(a: Vec3, b: Vec3, c: Vec3, d: Vec3, tolerance: number = 1e-5): boolean {
+  // Taken from: Real-Time Collision Detection - Christer Ericson (Section: Closest Point on Tetrahedron to Point)
+  // With p = 0
+
+  // Test if point p and d lie on opposite sides of plane through abc
+  ab.subtractVectors(b, a);
+  ac.subtractVectors(c, a);
+  ad.subtractVectors(d, a);
+
+  n.crossVectors(ab, ac);
+  const signP = a.dot(n); // [AP AB AC]
+  const signD = ad.dot(n); // [AD AB AC]
+
+  // Points on opposite sides if expression signs are the same
+  // Note that we left out the minus sign in signp so we need to check > 0 instead of < 0 as in Christer's book
+  // We compare against a small negative value to allow for a little bit of slop in the calculations
+  return signP * signD > -tolerance;
+}

package/src/collision/closestPoints/isOriginOutsideOfTrianglePlanes.ts

@@ -0,0 +1,72 @@
+import { Vec3 } from "../../math/vec3";
+import { Vec4 } from "../../math/vec4";
+
+const ab = /*@__PURE__*/ Vec3.create();
+const ac = /*@__PURE__*/ Vec3.create();
+const ad = /*@__PURE__*/ Vec3.create();
+const bd = /*@__PURE__*/ Vec3.create();
+const bc = /*@__PURE__*/ Vec3.create();
+const ab_cross_ac = /*@__PURE__*/ Vec3.create();
+const ac_cross_ad = /*@__PURE__*/ Vec3.create();
+const ad_cross_ab = /*@__PURE__*/ Vec3.create();
+const bd_cross_bc = /*@__PURE__*/ Vec3.create();
+const signP = /*@__PURE__*/ Vec4.create();
+const signD = /*@__PURE__*/ Vec4.create();
+
+export function isOriginOutsideOfTrianglePlanes(
+  outResult: Vec4,
+  a: Vec3,
+  b: Vec3,
+  c: Vec3,
+  d: Vec3,
+  tolerance: number = 1e-5
+): void {
+  ab.subtractVectors(b, a);
+  ac.subtractVectors(c, a);
+  ad.subtractVectors(d, a);
+  bd.subtractVectors(d, b);
+  bc.subtractVectors(c, b);
+
+  ab_cross_ac.crossVectors(ab, ac);
+  ac_cross_ad.crossVectors(ac, ad);
+  ad_cross_ab.crossVectors(ad, ab);
+  bd_cross_bc.crossVectors(bd, bc);
+
+  // For each plane get the side on which the origin is
+  signP.x = a.dot(ab_cross_ac); // ABC
+  signP.y = a.dot(ac_cross_ad); // ACD
+  signP.z = a.dot(ad_cross_ab); // ADB
+  signP.w = b.dot(bd_cross_bc); // BDC
+
+  // For each plane get the side that is outside (determined by the 4th point)
+  signD.x = ad.dot(ab_cross_ac); // D
+  signD.y = ab.dot(ac_cross_ad); // B
+  signD.z = ac.dot(ad_cross_ab); // C
+  signD.w = -ab.dot(bd_cross_bc); // A
+
+  // handle all signD components are positive
+  const allPositive = signD.x > 0 && signD.y > 0 && signD.z > 0 && signD.w > 0;
+  if (allPositive) {
+    outResult.x = signP.x >= -tolerance ? 1 : 0;
+    outResult.y = signP.y >= -tolerance ? 1 : 0;
+    outResult.z = signP.z >= -tolerance ? 1 : 0;
+    outResult.w = signP.w >= -tolerance ? 1 : 0;
+    return;
+  }
+
+  // handle all signD components are negative
+  const allNegative = signD.x < 0 && signD.y < 0 && signD.z < 0 && signD.w < 0;
+  if (allNegative) {
+    outResult.x = signP.x <= tolerance ? 1 : 0;
+    outResult.y = signP.y <= tolerance ? 1 : 0;
+    outResult.z = signP.z <= tolerance ? 1 : 0;
+    outResult.w = signP.w <= tolerance ? 1 : 0;
+    return;
+  }
+
+  // handle mixed signs, degenerate tetrahedron
+  outResult.x = 1;
+  outResult.y = 1;
+  outResult.z = 1;
+  outResult.w = 1;
+}

package/src/collision/collide/collide.ts

@@ -0,0 +1,146 @@
+import {
+  BooleanType,
+  createClass,
+  LazyReferenceType,
+  MonomorphType,
+  NumberType,
+  PropertyDefinitionMap,
+  PropertyDefinitionReference,
+} from "monomorph";
+import { Vec3 } from "../../math/vec3";
+import { Face } from "../../physics/manifold/Face";
+import { Body } from "../../physics/Body";
+
+export const enum CollisionStatus {
+  NotColliding,
+  Colliding,
+  Indeterminate,
+}
+
+const collisionResultProps = {
+  status: NumberType(0),
+  hasContact: BooleanType(false),
+  penetration: NumberType(0.0),
+  contactPointA: MonomorphType(Vec3),
+  contactPointB: MonomorphType(Vec3),
+  normalA: MonomorphType(Vec3),
+  normalB: MonomorphType(Vec3),
+  momentArmA: MonomorphType(Vec3),
+  momentArmB: MonomorphType(Vec3),
+  surfaceNormalA: MonomorphType(Vec3),
+  surfaceNormalB: MonomorphType(Vec3),
+  bodyA: LazyReferenceType((() => Body) as () => never) as PropertyDefinitionReference<Body | null, true>,
+  bodyB: LazyReferenceType((() => Body) as () => never) as PropertyDefinitionReference<Body | null, true>,
+  subShapeIdA: NumberType(0),
+  subShapeIdB: NumberType(0),
+  isBackFace: BooleanType(false),
+  faceA: MonomorphType(Face),
+  faceB: MonomorphType(Face),
+} as const satisfies PropertyDefinitionMap;
+
+export class CollisionResult extends createClass<CollisionResult, typeof collisionResultProps>(collisionResultProps) {
+  reset() {
+    this.status = CollisionStatus.Indeterminate;
+    this.hasContact = false;
+    this.penetration = 0;
+    this.bodyA = null;
+    this.bodyB = null;
+    this.subShapeIdA = 0;
+    this.subShapeIdB = 0;
+    this.isBackFace = false;
+    this.faceA.clear();
+    this.faceB.clear();
+  }
+
+  /**
+   * swaps the A and B data
+   */
+  swap() {
+    this.contactPointA.swap(this.contactPointB);
+    this.normalA.swap(this.normalB);
+    this.momentArmA.swap(this.momentArmB);
+    this.surfaceNormalA.swap(this.surfaceNormalB);
+
+    const tempBody = this.bodyA;
+    this.bodyA = this.bodyB;
+    this.bodyB = tempBody;
+
+    const tempSubShapeId = this.subShapeIdA;
+    this.subShapeIdA = this.subShapeIdB;
+    this.subShapeIdB = tempSubShapeId;
+
+    // this.faceA.swap(this.faceB);
+    const tempFace = this.faceA;
+    this.faceA = this.faceB;
+    this.faceB = tempFace;
+  }
+}
+
+export class CollisionCollector {
+  static initialEarlyOutFraction: number = Infinity;
+  static shouldEarlyOutFraction: number = -Infinity;
+  earlyOutFraction: number = CollisionCollector.initialEarlyOutFraction;
+  body2: Body | null = null;
+
+  getEarlyOutFraction(): number {
+    return CollisionCollector.initialEarlyOutFraction;
+    // return this.earlyOutFraction;
+    // return CollisionCollector.shouldEarlyOutFraction;
+  }
+
+  getPositiveEarlyOutFraction(): number {
+    return Math.max(Number.MIN_VALUE, this.earlyOutFraction);
+  }
+
+  reset() {
+    this.earlyOutFraction = CollisionCollector.initialEarlyOutFraction;
+    this.body2 = null;
+
+    return this;
+  }
+
+  addHit(result: CollisionResult): void {}
+
+  addMiss(): void {}
+}
+
+export const enum CollectFacesMode {
+  CollectFaces,
+  NoFaces,
+}
+
+export const enum ActiveEdgeMode {
+  CollideOnlyWithActive,
+  CollideWithAll,
+}
+
+export const enum BackFaceMode {
+  IgnoreBackFaces,
+  CollideWithBackFaces,
+}
+
+export interface CollisionSettings {
+  maxSeparation: number;
+  collisionTolerance: number;
+  activeEdgeMode: ActiveEdgeMode;
+  collectFacesMode: CollectFacesMode;
+  penetrationTolerance: number;
+  activeEdgeMovementDirectionX: number;
+  activeEdgeMovementDirectionY: number;
+  activeEdgeMovementDirectionZ: number;
+  backFaceMode: BackFaceMode;
+}
+
+export function createDefaultCollisionSettings() {
+  return {
+    maxSeparation: 0.0,
+    collisionTolerance: 1e-4,
+    activeEdgeMode: ActiveEdgeMode.CollideOnlyWithActive,
+    collectFacesMode: CollectFacesMode.NoFaces,
+    penetrationTolerance: 1e-4,
+    activeEdgeMovementDirectionX: 0.0,
+    activeEdgeMovementDirectionY: 0.0,
+    activeEdgeMovementDirectionZ: 0.0,
+    backFaceMode: BackFaceMode.IgnoreBackFaces,
+  } satisfies CollisionSettings;
+}

package/src/collision/collide/collideCompoundVsCompound.ts

@@ -0,0 +1,60 @@
+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 transformSubShapeToA = /*@__PURE__*/ Isometry.create();
+const transformSubShapeAToWorld = /*@__PURE__*/ Isometry.create();
+
+const transformSubShapeToB = /*@__PURE__*/ Isometry.create();
+const transformSubShapeBToWorld = /*@__PURE__*/ Isometry.create();
+
+// the results are in world space
+export function collideCompoundVsCompound(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: CompoundShape,
+  shapeB: CompoundShape,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+): void {
+  let indexA = 0;
+  for (const { shape: subShapeA, transform: transformA } of shapeA.shapes) {
+    transformSubShapeToA.fromRotationAndTranslation(transformA.rotation, transformA.position);
+    transformSubShapeAToWorld.matrix.multiplyMatrices(isometryA.matrix, transformSubShapeToA.matrix);
+
+    let indexB = 0;
+    for (const { shape: subShapeB, transform: transformB } of shapeB.shapes) {
+      transformSubShapeToB.fromRotationAndTranslation(transformB.rotation, transformB.position);
+      transformSubShapeBToWorld.matrix.multiplyMatrices(isometryB.matrix, transformSubShapeToB.matrix);
+
+      collideConvexVsConvex(
+        penetrationDepthModule,
+        collector,
+        subShapeA as ConvexShape,
+        subShapeB as ConvexShape,
+        transformSubShapeAToWorld,
+        transformSubShapeBToWorld,
+        settings,
+        bodyA,
+        bodyB,
+        initialDirection,
+        indexA,
+        indexB
+      );
+
+      indexB++;
+    }
+    indexA++;
+  }
+}

package/src/collision/collide/collideCompoundVsConvex.ts

@@ -0,0 +1,59 @@
+import { Isometry } from "../../math/isometry";
+import { Vec3 } from "../../math/vec3";
+import { PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { CollisionCollector, CollisionSettings } from "./collide";
+import { ConvexWithcomputeSupportShape } from "../../shape/Convex";
+import { CompoundShape } from "../../shape/CompoundShape";
+import { collideConvexVsConvex } from "./collideConvexVsConvex";
+import { Body } from "../../physics/Body";
+import { ConvexShape } from "../../shape/Shape";
+import { BasicTransform } from "../../math/BasicTransform";
+
+const transformSubShapeToA = /*@__PURE__*/ Isometry.create();
+const transformSubShapeToWorld = /*@__PURE__*/ Isometry.create();
+
+// the results are in world space
+export function collideCompoundVsConvex(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: CompoundShape,
+  shapeB: ConvexWithcomputeSupportShape,
+  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 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);
+
+    // collide the shapes. TODO: this should be convex vs convex for now, but may be expanded in the future
+    collideConvexVsConvex(
+      penetrationDepthModule,
+      collector,
+      shape,
+      shapeB,
+      transformSubShapeToWorld,
+      isometryB,
+      settings,
+      bodyA,
+      bodyB,
+      initialDirection,
+      index,
+      0
+    );
+
+    index++;
+  }
+}