@perplexdotgg/bounce 1.0.0 → 1.0.1

package/src/builders/HeightMapBuilder.ts

@@ -1,414 +0,0 @@
-import { InputType } from "monomorph";
-import { computeClosestPowersOfTwo, degreesToRadians, isPowerOf2 } from "../math/scalar";
-import { Vec3 } from "../math/vec3";
-import {
-  computeCornerIndicesInGrid,
-  computeNumberOfCells,
-  computeNumberOfLevels,
-  HeightMap,
-  updateShape,
-} from "../shape/HeightMap";
-import { Triangle } from "../shape/Triangle";
-import { Tuple4 } from "../types";
-import { isEdgeActive } from "../collision/activeEdge";
-
-const cos5Degrees = Math.cos(degreesToRadians(5));
-
-const a1 = /*@__PURE__*/ Vec3.create();
-const b1 = /*@__PURE__*/ Vec3.create();
-const c1 = /*@__PURE__*/ Vec3.create();
-const a2 = /*@__PURE__*/ Vec3.create();
-const b2 = /*@__PURE__*/ Vec3.create();
-const c2 = /*@__PURE__*/ Vec3.create();
-const triangleLeftOfEdge = /*@__PURE__*/ Triangle.create();
-const triangleRightOfEdge = /*@__PURE__*/ Triangle.create();
-const normalLeftOfEdge = /*@__PURE__*/ Vec3.create();
-const normalRightOfEdge = /*@__PURE__*/ Vec3.create();
-const edge = /*@__PURE__*/ Vec3.create();
-
-export class HeightMapBuilder {
-  buildHeightMapQuadtree(heightMap: HeightMap): void {
-    const numberOfSubdivisions = heightMap.subdivisionsCount;
-
-    // #v-ifdef DEV
-    // assert that number of subdivisions is a power of 2
-    if (isPowerOf2(numberOfSubdivisions) === false) {
-      throw new Error(`expected number of subdivisions to be a power of 2, got ${numberOfSubdivisions} instead`);
-    }
-    // #v-endif
-
-    const index: Tuple4<number> = [0, 0, 0, 0];
-
-    // walk through each layer starting from the bottom, aggregating min and max heights for each cell
-    let currentNumberOfSubdivisions = heightMap.subdivisionsCount;
-    while (currentNumberOfSubdivisions >= 1) {
-      // get the level of the current layer
-      const level = Math.log2(currentNumberOfSubdivisions);
-
-      // get offset for the current layer
-      const offset = computeNumberOfCells(currentNumberOfSubdivisions / 2);
-
-      // case: we're in the bottom layer, the 4 "children" heights are queried from the heightMap data itself
-      if (currentNumberOfSubdivisions === heightMap.subdivisionsCount) {
-        // for each cell in the current layer
-        for (let x = 0; x < currentNumberOfSubdivisions; x++) {
-          for (let z = 0; z < currentNumberOfSubdivisions; z++) {
-            // get the current level corner vertex indices
-            computeCornerIndicesInGrid(index, x, z, currentNumberOfSubdivisions + 1);
-
-            const blHeight = heightMap.heights[index[0]];
-            const brHeight = heightMap.heights[index[1]];
-            const tlHeight = heightMap.heights[index[2]];
-            const trHeight = heightMap.heights[index[3]];
-
-            const minHeight = Math.min(blHeight, brHeight, tlHeight, trHeight);
-            const maxHeight = Math.max(blHeight, brHeight, tlHeight, trHeight);
-
-            const flatIndex = z + x * currentNumberOfSubdivisions;
-            heightMap.minHeights[offset + flatIndex] = minHeight;
-            heightMap.maxHeights[offset + flatIndex] = maxHeight;
-            heightMap.levels[offset + flatIndex] = level;
-          }
-        }
-      }
-      // case: we're in a higher layer, the 4 "children" heights are queried from the lower layer
-      else {
-        // get the lower level offset
-        const lowerOffset = computeNumberOfCells(currentNumberOfSubdivisions);
-
-        for (let x = 0; x < currentNumberOfSubdivisions; x++) {
-          for (let z = 0; z < currentNumberOfSubdivisions; z++) {
-            // get the lower level corner block indices
-            computeCornerIndicesInGrid(index, x * 2, z * 2, currentNumberOfSubdivisions * 2);
-
-            const blMinHeight = heightMap.minHeights[lowerOffset + index[0]];
-            const brMinHeight = heightMap.minHeights[lowerOffset + index[1]];
-            const tlMinHeight = heightMap.minHeights[lowerOffset + index[2]];
-            const trMinHeight = heightMap.minHeights[lowerOffset + index[3]];
-
-            const blMaxHeight = heightMap.maxHeights[lowerOffset + index[0]];
-            const brMaxHeight = heightMap.maxHeights[lowerOffset + index[1]];
-            const tlMaxHeight = heightMap.maxHeights[lowerOffset + index[2]];
-            const trMaxHeight = heightMap.maxHeights[lowerOffset + index[3]];
-
-            const minHeight = Math.min(blMinHeight, brMinHeight, tlMinHeight, trMinHeight);
-            const maxHeight = Math.max(blMaxHeight, brMaxHeight, tlMaxHeight, trMaxHeight);
-
-            const flatIndex = z + x * currentNumberOfSubdivisions;
-            heightMap.minHeights[offset + flatIndex] = minHeight;
-            heightMap.maxHeights[offset + flatIndex] = maxHeight;
-            heightMap.levels[offset + flatIndex] = level;
-          }
-        }
-      }
-
-      currentNumberOfSubdivisions /= 2;
-    }
-  }
-
-  buildActiveEdges(heightMap: HeightMap): void {
-    // TODO: this can be cleaned up to avoid repetition of logic
-
-    // we store 1 uint32 per triangle, using the first 3 bits to represent the active edges
-
-    // for each quad
-
-    let activeEdge = 0b000;
-    let result = 0b000;
-
-    for (let row = 0; row < heightMap.subdivisionsCount; row++) {
-      for (let col = 0; col < heightMap.subdivisionsCount; col++) {
-        // compute flat index
-        const index = col + row * heightMap.subdivisionsCount;
-
-        // outer edge flags
-        const isFirstRow = row === 0;
-        const isLastRow = row === heightMap.subdivisionsCount - 1;
-        const isFirstColumn = col === 0;
-        const isLastColumn = col === heightMap.subdivisionsCount - 1;
-
-        // triangle indices
-        const firstTriangleIndex = index * 2 + 0;
-        const secondTriangleIndex = index * 2 + 1;
-
-        // TRIANGLE ABC
-        activeEdge = 0b000;
-        result = 0b000;
-
-        // check if edge 0 is active (AB)
-
-        // if edge is an outer edge, it is active
-        if (isFirstRow) {
-          activeEdge |= 0b001;
-        }
-        // if edge is an interior edge, get both triangles on either side of the edge
-        else {
-          // get triangles
-          heightMap.computeVertex(a1, col + 0, row + 0);
-          heightMap.computeVertex(b1, col + 1, row + 0);
-          heightMap.computeVertex(c1, col + 0, row + 1);
-          triangleLeftOfEdge.set({ a: a1, b: b1, c: c1 });
-
-          heightMap.computeVertex(a2, col + 1, row + 0);
-          heightMap.computeVertex(b2, col + 0, row + 0);
-          heightMap.computeVertex(c2, col + 1, row - 1);
-          triangleRightOfEdge.set({ a: a2, b: b2, c: c2 });
-
-          // get normals
-          triangleLeftOfEdge.computeNormal(normalLeftOfEdge);
-          triangleRightOfEdge.computeNormal(normalRightOfEdge);
-
-          // get edge direction
-          edge.subtractVectors(b1, a1);
-          edge.normalize();
-
-          // check if edge is active
-          result = isEdgeActive(normalLeftOfEdge, normalRightOfEdge, edge, cos5Degrees) ? 0b001 : 0b000;
-          activeEdge |= result;
-        }
-
-        // check if edge 1 is active (BC)
-
-        // this edge is always interior, get both triangles on either side of the edge
-
-        // get triangles, left is ABC, right is BDC
-        heightMap.computeVertex(a1, col + 1, row + 0);
-        heightMap.computeVertex(b1, col + 0, row + 1);
-        heightMap.computeVertex(c1, col + 0, row + 0);
-        triangleLeftOfEdge.set({ a: a1, b: b1, c: c1 });
-
-        heightMap.computeVertex(a2, col + 1, row + 0);
-        heightMap.computeVertex(b2, col + 1, row + 1);
-        heightMap.computeVertex(c2, col + 0, row + 1);
-        triangleRightOfEdge.set({ a: a2, b: b2, c: c2 });
-
-        // get normals
-        triangleLeftOfEdge.computeNormal(normalLeftOfEdge);
-        triangleRightOfEdge.computeNormal(normalRightOfEdge);
-
-        // get edge direction
-        edge.subtractVectors(b1, a1);
-        edge.normalize();
-
-        // check if edge is active
-        result = isEdgeActive(normalLeftOfEdge, normalRightOfEdge, edge, cos5Degrees) ? 0b010 : 0b000;
-        activeEdge |= result;
-
-        // check if edge 2 is active (CA)
-
-        // if edge is an outer edge, it is active
-        if (isFirstColumn) {
-          activeEdge |= 0b100;
-        }
-
-        // if edge is an interior edge, get both triangles on either side of the edge
-        else {
-          // get triangles
-          heightMap.computeVertex(a1, col + 0, row + 1);
-          heightMap.computeVertex(b1, col + 0, row + 0);
-          heightMap.computeVertex(c1, col + 1, row + 0);
-          triangleLeftOfEdge.set({ a: a1, b: b1, c: c1 });
-
-          heightMap.computeVertex(a2, col + 0, row + 1);
-          heightMap.computeVertex(b2, col - 1, row + 1);
-          heightMap.computeVertex(c2, col + 0, row + 0);
-          triangleRightOfEdge.set({ a: a2, b: b2, c: c2 });
-
-          // get normals
-          triangleLeftOfEdge.computeNormal(normalLeftOfEdge);
-          triangleRightOfEdge.computeNormal(normalRightOfEdge);
-
-          // get edge direction
-          edge.subtractVectors(b1, a1);
-          edge.normalize();
-
-          // check if edge is active
-          result = isEdgeActive(normalLeftOfEdge, normalRightOfEdge, edge, cos5Degrees) ? 0b100 : 0b000;
-          activeEdge |= result;
-        }
-
-        // set active edges for triangle ABC
-        heightMap.activeEdges[firstTriangleIndex] = activeEdge;
-
-        // TRIANGLE DCB
-
-        activeEdge = 0b000;
-        result = 0b000;
-
-        // check if edge 0 is active (DC)
-
-        // if edge is an outer edge, it is active
-        if (isLastRow) {
-          activeEdge |= 0b001;
-        }
-
-        // if edge is an interior edge, get both triangles on either side of the edge
-        else {
-          // get triangles
-          heightMap.computeVertex(a1, col + 1, row + 1);
-          heightMap.computeVertex(b1, col + 0, row + 1);
-          heightMap.computeVertex(c1, col + 1, row + 0);
-          triangleLeftOfEdge.set({ a: a1, b: b1, c: c1 });
-
-          heightMap.computeVertex(a2, col + 1, row + 1);
-          heightMap.computeVertex(b2, col + 0, row + 2);
-          heightMap.computeVertex(c2, col + 0, row + 1);
-          triangleRightOfEdge.set({ a: a2, b: b2, c: c2 });
-
-          // get normals
-          triangleLeftOfEdge.computeNormal(normalLeftOfEdge);
-          triangleRightOfEdge.computeNormal(normalRightOfEdge);
-
-          // get edge direction
-          edge.subtractVectors(b1, a1);
-          edge.normalize();
-
-          // check if edge is active
-          result = isEdgeActive(normalLeftOfEdge, normalRightOfEdge, edge, cos5Degrees) ? 0b001 : 0b000;
-          activeEdge |= result;
-        }
-
-        // check if edge 1 is active (CB)
-
-        // this edge is always interior, get both triangles on either side of the edge
-
-        // get triangles
-        heightMap.computeVertex(a1, col + 0, row + 1);
-        heightMap.computeVertex(b1, col + 1, row + 0);
-        heightMap.computeVertex(c1, col + 1, row + 1);
-        triangleLeftOfEdge.set({ a: a1, b: b1, c: c1 });
-
-        heightMap.computeVertex(a2, col + 0, row + 1);
-        heightMap.computeVertex(b2, col + 0, row + 0);
-        heightMap.computeVertex(c2, col + 1, row + 0);
-        triangleRightOfEdge.set({ a: a2, b: b2, c: c2 });
-
-        // get normals
-        triangleLeftOfEdge.computeNormal(normalLeftOfEdge);
-        triangleRightOfEdge.computeNormal(normalRightOfEdge);
-
-        // get edge direction
-        edge.subtractVectors(b1, a1);
-        edge.normalize();
-
-        // check if edge is active
-        result = isEdgeActive(normalLeftOfEdge, normalRightOfEdge, edge, cos5Degrees) ? 0b010 : 0b000;
-        activeEdge |= result;
-
-        // check if edge 2 is active (BD)
-
-        // if edge is an outer edge, it is active
-        if (isLastColumn) {
-          activeEdge |= 0b100;
-        }
-
-        // if edge is an interior edge, get both triangles on either side of the edge
-        else {
-          // get triangles
-          heightMap.computeVertex(a1, col + 1, row + 0);
-          heightMap.computeVertex(b1, col + 1, row + 1);
-          heightMap.computeVertex(c1, col + 0, row + 1);
-          triangleLeftOfEdge.set({ a: a1, b: b1, c: c1 });
-
-          heightMap.computeVertex(a2, col + 1, row + 0);
-          heightMap.computeVertex(b2, col + 2, row + 0);
-          heightMap.computeVertex(c2, col + 1, row + 1);
-          triangleRightOfEdge.set({ a: a2, b: b2, c: c2 });
-
-          // get normals
-          triangleLeftOfEdge.computeNormal(normalLeftOfEdge);
-          triangleRightOfEdge.computeNormal(normalRightOfEdge);
-
-          // get edge direction
-          edge.subtractVectors(b1, a1);
-          edge.normalize();
-
-          // check if edge is active
-          result = isEdgeActive(normalLeftOfEdge, normalRightOfEdge, edge, cos5Degrees) ? 0b100 : 0b000;
-          activeEdge |= result;
-        }
-
-        // set active edges for triangle DCB
-        heightMap.activeEdges[secondTriangleIndex] = activeEdge;
-      }
-    }
-  }
-
-  buildHeightMap(
-    vertexCount: { width: number; depth: number },
-    extents: InputType<Vec3>,
-    heights: Float32Array | Float64Array | number[],
-    heightMapPool?: typeof HeightMap.Pool
-  ): HeightMap {
-    if (vertexCount.width < 2 || vertexCount.depth < 2) {
-      throw new Error(`vertexCount must be at least 2x2: ${vertexCount.width}x${vertexCount.depth}`);
-    }
-
-    if (vertexCount.width !== vertexCount.depth) {
-      throw new Error(`non-square heightmaps are not yet supported:  ${vertexCount.width}x${vertexCount.depth}`);
-    }
-
-    const subdivisionsCount = vertexCount.width - 1; // number of subdivisions is one less than the number of vertices
-    if (!isPowerOf2(subdivisionsCount)) {
-      const { previous, next } = computeClosestPowersOfTwo(subdivisionsCount);
-      throw new Error(
-        `non-power-of-two sub-divisions are not yet supported. the closest valid vertex counts are: [${previous + 1}, ${
-          next + 1
-        }]`
-      );
-    }
-
-    if (heights.length !== vertexCount.width * vertexCount.depth) {
-      throw new Error(
-        `heights length must match vertex count: ${vertexCount.width * vertexCount.depth}, got ${
-          heights.length
-        } instead`
-      );
-    }
-
-    for (let i = 0; i < heights.length; i++) {
-      const height = heights[i];
-      if (height < 0.0 || height > 1.0) {
-        throw new Error(`heights must be normalized to the range [0, 1], got ${height} at index ${i} instead`);
-      }
-    }
-
-    const numberOfQuads = subdivisionsCount ** 2;
-    const numberOfTriangles = numberOfQuads * 2;
-    const numberOfCells = computeNumberOfCells(subdivisionsCount);
-
-    actualExtents.fromArray([1, 1, 1]);
-    actualExtents.set(extents);
-
-    scale.x = actualExtents.x / subdivisionsCount;
-    scale.y = actualExtents.y;
-    scale.z = actualExtents.z / subdivisionsCount;
-
-    positionOffset.x = -actualExtents.x * 0.5;
-    positionOffset.y = 0.0;
-    positionOffset.z = -actualExtents.z * 0.5;
-
-    // 2. allocate the heightMap
-    const heightMap = HeightMap.create({
-      subdivisionsCount: subdivisionsCount,
-      scale: scale,
-      positionOffset: positionOffset,
-    }, heightMapPool);
-    heightMap.heights = Array.from(heights);
-    heightMap.activeEdges = new Array(numberOfTriangles).fill(0);
-    heightMap.minHeights = new Array(numberOfCells).fill(Number.POSITIVE_INFINITY);
-    heightMap.maxHeights = new Array(numberOfCells).fill(Number.NEGATIVE_INFINITY);
-    heightMap.levels = new Array(numberOfCells).fill(0);
-
-    // 3. build the quadtree and active edges
-    this.buildActiveEdges(heightMap);
-    this.buildHeightMapQuadtree(heightMap);
-
-    updateShape(heightMap);
-    return heightMap;
-  }
-}
-
-const scale = /*@__PURE__*/ Vec3.create();
-const positionOffset = /*@__PURE__*/ Vec3.create();
-const actualExtents = /*@__PURE__*/ Vec3.create();

package/src/builders/TriangleMeshBuilder.ts

@@ -1,92 +0,0 @@
-import { Vec3 } from "../math/vec3";
-import { TriangleMeshBvhTreeOptions, TriangleMeshBvhTree, TriangleMeshBvhNode } from "../physics/broadphase/TriangleMeshBvhTree";
-import { Triangle } from "../shape/Triangle";
-import { TriangleMesh, updateShape } from "../shape/TriangleMesh";
-import { ConvexHullBuilder } from "./ConvexHullBuilder";
-
-export interface BuildTriangleMeshParams {
-  vertexPositions: Float32Array;
-  faceIndices: Uint32Array;
-  bvhOptions: TriangleMeshBvhTreeOptions;
-}
-
-export class TriangleMeshBuilder {
-  convexHullBuilder: ConvexHullBuilder;
-
-  constructor() {
-    this.convexHullBuilder = new ConvexHullBuilder();
-  }
-
-  build(
-    params: BuildTriangleMeshParams,
-    triangleMeshPool?: typeof TriangleMesh.Pool,
-    bvhNodePool?: typeof TriangleMeshBvhNode.Pool,
-    bvhTreePool?: typeof TriangleMeshBvhTree.Pool,
-    vertexPositionPool?: typeof Vec3.Pool,
-    faceIndexPool?: typeof Vec3.Pool,
-    trianglePool?: typeof Triangle.Pool
-  ) {
-    const vertexPositions = vertexPositionPool || new Vec3.Pool(params.vertexPositions.length / 3);
-    const faceIndices = faceIndexPool || new Vec3.Pool(params.faceIndices.length / 3);
-    const triangles = trianglePool || new Triangle.Pool(params.faceIndices.length / 3);
-    const mesh = TriangleMesh.create({
-      vertexPositions: { pool: vertexPositions },
-      faceIndices: { pool: faceIndices },
-      triangles: { pool: triangles },
-    }, triangleMeshPool);
-
-    for (let i = 0; i < params.vertexPositions.length; i += 3) {
-      mesh.vertexPositions.create(
-        {
-          x: params.vertexPositions[i + 0],
-          y: params.vertexPositions[i + 1],
-          z: params.vertexPositions[i + 2],
-        },
-      );
-    }
-
-    for (let i = 0; i < params.faceIndices.length; i += 3) {
-      mesh.faceIndices.create(
-        {
-          x: params.faceIndices[i + 0],
-          y: params.faceIndices[i + 1],
-          z: params.faceIndices[i + 2],
-        },
-      );
-    }
-
-    let subShapeId = 0;
-    for (const face of mesh.faceIndices!) {
-      const triangle = mesh.triangles.create(
-        {
-          a: mesh.vertexPositions.getAtIndex(face.x)!,
-          b: mesh.vertexPositions.getAtIndex(face.y)!,
-          c: mesh.vertexPositions.getAtIndex(face.z)!,
-        },
-      );
-      triangle.computeLocalBounds(triangle.computedBounds);
-      triangle.computeNormal(triangle.normal);
-      triangle.subShapeId = subShapeId++;
-      triangle.activeEdges = 0b111;
-    }
-
-    updateShape(mesh);
-
-    const nodes = bvhNodePool || new TriangleMeshBvhNode.Pool();
-    bvhTreePool = bvhTreePool || new TriangleMeshBvhTree.Pool();
-    mesh.bvh = TriangleMeshBvhTree.create({
-      nodes: { pool: nodes },
-    }, bvhTreePool);
-
-    mesh.bvh.build({
-      mesh: mesh,
-      bvhTreeOptions: params.bvhOptions,
-    }, triangles);
-
-    const hull = this.convexHullBuilder.buildFromPoints(params.vertexPositions, 0.0, 1e-3);
-    mesh.computedVolume = hull.computedVolume;
-    mesh.inertia.copy(hull.inertia);
-
-    return mesh;
-  }
-}

package/src/collision/CastShapesModule.ts

@@ -1,184 +0,0 @@
-import { Isometry } from "../math/isometry";
-import { Shape, ShapeType } from "../shape/Shape";
-import { Vec3 } from "../math/vec3";
-import { castConvexVsConvex } from "./cast/castConvexVsConvex";
-import { PenetrationDepthModule } from "./gjk/PenetrationDepthModule";
-import { castCompoundVsConvex } from "./cast/castCompoundVsConvex";
-import { castConvexVsCompound } from "./cast/castConvexVsCompound";
-import { CastCollector, CastSettings, RayCastSettings } from "./cast/cast";
-import { Body } from "../physics/Body";
-import { castConvexVsHeightMap } from "./cast/castConvexVsHeightMap";
-import { castConvexVsTriangleMesh } from "./cast/castConvexVsTriangleMesh";
-import { Ray } from "../shape/Ray";
-import { castRayVsConvex } from "./cast/castRayVsConvex";
-import { castRayVsCompound } from "./cast/castRayVsCompound";
-import { castRayVsTriangleMesh } from "./cast/castRayVsTriangleMesh";
-import { castRayVsHeightMap } from "./cast/castRayVsHeightMap";
-
-const castShapesFns = {
-  [ShapeType.sphere]: {
-    [ShapeType.box]: castConvexVsConvex,
-    [ShapeType.capsule]: castConvexVsConvex,
-    [ShapeType.compoundShape]: castConvexVsCompound,
-    [ShapeType.convexHull]: castConvexVsConvex,
-    [ShapeType.cylinder]: castConvexVsConvex,
-    [ShapeType.heightMap]: castConvexVsHeightMap,
-    [ShapeType.sphere]: castConvexVsConvex,
-    [ShapeType.triangleMesh]: castConvexVsTriangleMesh,
-  },
-  [ShapeType.box]: {
-    [ShapeType.box]: castConvexVsConvex,
-    [ShapeType.capsule]: castConvexVsConvex,
-    [ShapeType.compoundShape]: castConvexVsCompound,
-    [ShapeType.convexHull]: castConvexVsConvex,
-    [ShapeType.cylinder]: castConvexVsConvex,
-    [ShapeType.heightMap]: castConvexVsHeightMap,
-    [ShapeType.sphere]: castConvexVsConvex,
-    [ShapeType.triangleMesh]: castConvexVsTriangleMesh,
-  },
-  [ShapeType.capsule]: {
-    [ShapeType.box]: castConvexVsConvex,
-    [ShapeType.capsule]: castConvexVsConvex,
-    [ShapeType.compoundShape]: castConvexVsCompound,
-    [ShapeType.convexHull]: castConvexVsConvex,
-    [ShapeType.cylinder]: castConvexVsConvex,
-    [ShapeType.heightMap]: castConvexVsHeightMap,
-    [ShapeType.sphere]: castConvexVsConvex,
-    [ShapeType.triangleMesh]: castConvexVsTriangleMesh,
-  },
-  [ShapeType.cylinder]: {
-    [ShapeType.box]: castConvexVsConvex,
-    [ShapeType.capsule]: castConvexVsConvex,
-    [ShapeType.compoundShape]: castConvexVsCompound,
-    [ShapeType.convexHull]: castConvexVsConvex,
-    [ShapeType.cylinder]: castConvexVsConvex,
-    [ShapeType.heightMap]: castConvexVsHeightMap,
-    [ShapeType.sphere]: castConvexVsConvex,
-    [ShapeType.triangleMesh]: castConvexVsTriangleMesh,
-  },
-  [ShapeType.compoundShape]: {
-    [ShapeType.box]: castCompoundVsConvex,
-    [ShapeType.capsule]: castCompoundVsConvex,
-    // [ShapeType.compoundShape]: castCompoundVsCompound,
-    [ShapeType.convexHull]: castCompoundVsConvex,
-    [ShapeType.cylinder]: castCompoundVsConvex,
-    // [ShapeType.heightMap]: castCompoundVsHeightMap,
-    [ShapeType.sphere]: castCompoundVsConvex,
-    // [ShapeType.triangleMesh]: castCompoundVsTriangleMesh,
-  },
-  // [ShapeType.heightMap]: {
-  //   [ShapeType.box]: castHeightMapVsConvex,
-  //   [ShapeType.capsule]: castHeightMapVsConvex,
-  //   [ShapeType.compoundShape]: castHeightMapVsCompound,
-  //   [ShapeType.convexHull]: castHeightMapVsConvex,
-  //   [ShapeType.cylinder]: castHeightMapVsConvex,
-  //   [ShapeType.heightMap]: castHeightMapVsHeightMap,
-  //   [ShapeType.sphere]: castHeightMapVsConvex,
-  //   [ShapeType.triangleMesh]: castHeightMapVsTriangleMesh,
-  // },
-  // [ShapeType.triangleMesh]: {
-  //   [ShapeType.box]: castTriangleMeshVsConvex,
-  //   [ShapeType.capsule]: castTriangleMeshVsConvex,
-  //   [ShapeType.compoundShape]: castTriangleMeshVsCompound,
-  //   [ShapeType.convexHull]: castTriangleMeshVsConvex,
-  //   [ShapeType.cylinder]: castTriangleMeshVsConvex,
-  //   [ShapeType.heightMap]: castTriangleMeshVsHeightMap,
-  //   [ShapeType.sphere]: castTriangleMeshVsConvex,
-  //   [ShapeType.triangleMesh]: castTriangleMeshVsTriangleMesh,
-  // },
-  // [ShapeType.triangle]: {
-  //   [ShapeType.box]: castTriangleVsConvex,
-  //   [ShapeType.sphere]: castTriangleVsConvex,
-  // },
-} as const;
-
-const raycastFns = {
-  [ShapeType.sphere]: castRayVsConvex,
-  [ShapeType.box]: castRayVsConvex,
-  [ShapeType.capsule]: castRayVsConvex,
-  [ShapeType.cylinder]: castRayVsConvex,
-  [ShapeType.compoundShape]: castRayVsCompound, // castRayVsCompound,
-  [ShapeType.convexHull]: castRayVsConvex,
-  [ShapeType.heightMap]: castRayVsHeightMap, // castRayVsHeightMap,
-  [ShapeType.triangleMesh]: castRayVsTriangleMesh, // castRayVsTriangleMesh,
-};
-
-export class CastShapesModule {
-  penetrationDepthModule: PenetrationDepthModule;
-
-  constructor(penetrationDepthModule: PenetrationDepthModule) {
-    this.penetrationDepthModule = penetrationDepthModule;
-  }
-
-  castRay(
-    collector: CastCollector,
-    ray: Ray,
-    shapeB: Shape,
-    isometryB: Isometry,
-    scaleB: number,
-    offset: Vec3,
-    settings: RayCastSettings,
-    bodyB: Body | null = null
-  ) {
-    const fn = raycastFns[shapeB.type as keyof typeof raycastFns];
-    if (!fn) {
-      return;
-    }
-    return fn(
-      this.penetrationDepthModule,
-      collector,
-      ray,
-      // @ts-ignore
-      shapeB,
-      isometryB,
-      scaleB,
-      offset,
-      settings,
-      bodyB
-    );
-  }
-
-  // casts two shapes that implement the ShapeWithType interface, using the query map
-  // the shapes must be in local space
-  // the isometries must transform the shapes into world space
-  // the results are in world space
-  castShapes(
-    collector: CastCollector,
-    shapeA: Shape,
-    isometryA: Isometry,
-    scaleA: number,
-    shapeB: Shape,
-    isometryB: Isometry,
-    scaleB: number,
-    displacement: Vec3,
-    offset: Vec3,
-    settings: CastSettings,
-    bodyA: Body | null = null,
-    bodyB: Body | null = null
-  ): void {
-    const keyA = shapeA.type as keyof typeof castShapesFns;
-    const keyB = shapeB.type as keyof (typeof castShapesFns)[keyof typeof castShapesFns];
-    const castFunction = castShapesFns[keyA][keyB];
-    if (!castFunction) {
-      throw new Error(`no cast function found for shapes with type ${keyA} and ${keyB}`);
-    }
-
-    return castFunction(
-      this.penetrationDepthModule,
-      collector,
-      // @ts-ignore
-      shapeA,
-      shapeB,
-      isometryA,
-      isometryB,
-      scaleA,
-      scaleB,
-      displacement,
-      offset,
-      settings,
-      undefined,
-      bodyA,
-      bodyB
-    );
-  }
-}