@perplexdotgg/bounce 1.0.0 → 1.0.2

package/src/collision/closestPoints/computeClosestPointOnLine.ts

@@ -1,30 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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++;
-  }
-}