@perplexdotgg/bounce 1.0.0

package/src/builders/HeightMapBuilder.ts

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

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

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