@perplexdotgg/bounce 1.0.0

package/src/collision/collide/collideConvexVsHeightMap.ts

@@ -0,0 +1,53 @@
+import { Isometry } from "../../math/isometry";
+import { Aabb } from "../../shape/Aabb";
+import { HeightMap } from "../../shape/HeightMap";
+import { ConvexShape } from "../../shape/Shape";
+import { PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { BackFaceMode, CollisionCollector, CollisionSettings } from "./collide";
+import { HeightMapCollider } from "../HeightMapCollider";
+import { Body } from "../../physics/Body";
+import { Vec3 } from "../../math/vec3";
+
+const isometryWorldToB = /*@__PURE__*/ Isometry.create();
+const isometryAToB = /*@__PURE__*/ Isometry.create();
+const shapeABoundsInBSpace = /*@__PURE__*/ Aabb.create();
+
+const heightMapCollider = /*@__PURE__*/ new HeightMapCollider();
+
+export function collideConvexVsHeightMap(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: ConvexShape,
+  shapeB: HeightMap,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+) {
+  // TODO: don't hardcode this option
+  settings.backFaceMode = BackFaceMode.CollideWithBackFaces;
+
+  heightMapCollider.triangleCollider.initialize(
+    penetrationDepthModule,
+    shapeA,
+    isometryA,
+    isometryB,
+    settings,
+    collector,
+    undefined,
+    bodyA,
+    bodyB
+  );
+
+  isometryWorldToB.matrix.invertMatrix(isometryB.matrix);
+  isometryAToB.matrix.multiplyMatrices(isometryWorldToB.matrix, isometryA.matrix);
+  shapeABoundsInBSpace.copy(shapeA.computedAabb);
+  shapeABoundsInBSpace.transform(isometryAToB);
+  shapeABoundsInBSpace.expand(settings.maxSeparation);
+  heightMapCollider.initialize(shapeABoundsInBSpace, bodyA, bodyB);
+  shapeB.walkHeightMap(heightMapCollider);
+}

package/src/collision/collide/collideConvexVsTriangleMesh.ts

@@ -0,0 +1,58 @@
+import { Isometry } from "../../math/isometry";
+import { Aabb } from "../../shape/Aabb";
+import { ConvexShape } from "../../shape/Shape";
+import { PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { ActiveEdgeMode, BackFaceMode, CollectFacesMode, CollisionCollector, CollisionSettings } from "./collide";
+import { TriangleMesh } from "../../shape/TriangleMesh";
+import { Triangle } from "../../shape/Triangle";
+import { TriangleCollider2 } from "../TriangleCollider2";
+import { Body } from "../../physics/Body";
+import { Vec3 } from "../../math/vec3";
+
+const isometryWorldToB = /*@__PURE__*/ Isometry.create();
+const isometryAToB = /*@__PURE__*/ Isometry.create();
+const shapeABoundsInBSpace = /*@__PURE__*/ Aabb.create();
+const triangleCollider = /*@__PURE__*/ new TriangleCollider2();
+
+function onHit(triangle: Triangle): boolean {
+  triangleCollider.collide(triangle, triangle.activeEdges, triangle.subShapeId, undefined, undefined, false);
+  return false;
+}
+
+export function collideConvexVsTriangleMesh(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: ConvexShape,
+  shapeB: TriangleMesh,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+): void {
+  // TODO: don't hardcode this option
+  settings.backFaceMode = BackFaceMode.IgnoreBackFaces;
+  settings.collectFacesMode = CollectFacesMode.CollectFaces;
+  settings.activeEdgeMode = ActiveEdgeMode.CollideWithAll;
+
+  triangleCollider.initialize(
+    penetrationDepthModule,
+    shapeA,
+    isometryA,
+    isometryB,
+    settings,
+    collector,
+    subShapeIdA,
+    bodyA,
+    bodyB
+  );
+  isometryWorldToB.matrix.invertMatrix(isometryB.matrix);
+  isometryAToB.matrix.multiplyMatrices(isometryWorldToB.matrix, isometryA.matrix);
+  shapeABoundsInBSpace.copy(shapeA.computedAabb);
+  shapeABoundsInBSpace.transform(isometryAToB);
+  shapeABoundsInBSpace.expand(settings.maxSeparation);
+  shapeB.bvh!.intersectAabb(onHit, shapeABoundsInBSpace);
+}

package/src/collision/collide/collideHeightMapVsCompound.ts

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

package/src/collision/collide/collideHeightMapVsConvex.ts

@@ -0,0 +1,53 @@
+import { Isometry } from "../../math/isometry";
+import { Vec3 } from "../../math/vec3";
+import { Aabb } from "../../shape/Aabb";
+import { HeightMap } from "../../shape/HeightMap";
+import { ConvexShape } from "../../shape/Shape";
+import { PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { BackFaceMode, CollisionCollector, CollisionSettings } from "./collide";
+import { HeightMapCollider } from "../HeightMapCollider";
+import { Body } from "../../physics/Body";
+
+const isometryWorldToA = /*@__PURE__*/ Isometry.create();
+const isometryBToA = /*@__PURE__*/ Isometry.create();
+const shapeBBoundsInASpace = /*@__PURE__*/ Aabb.create();
+
+const heightMapCollider = /*@__PURE__*/ new HeightMapCollider();
+
+export function collideHeightMapVsConvex(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: HeightMap,
+  shapeB: ConvexShape,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+) {
+  // TODO: don't hardcode this option
+  settings.backFaceMode = BackFaceMode.CollideWithBackFaces;
+
+  heightMapCollider.triangleCollider.initialize(
+    penetrationDepthModule,
+    shapeB,
+    isometryB,
+    isometryA,
+    settings,
+    collector,
+    undefined,
+    bodyB,
+    bodyA
+  );
+
+  isometryWorldToA.matrix.invertMatrix(isometryA.matrix);
+  isometryBToA.matrix.multiplyMatrices(isometryWorldToA.matrix, isometryB.matrix);
+  shapeBBoundsInASpace.copy(shapeB.computedAabb);
+  shapeBBoundsInASpace.transform(isometryBToA);
+  shapeBBoundsInASpace.expand(settings.maxSeparation);
+  heightMapCollider.initialize(shapeBBoundsInASpace, bodyB, bodyA);
+  shapeA.walkHeightMap(heightMapCollider);
+}

package/src/collision/collide/collideSphereVsSphere.ts

@@ -0,0 +1,81 @@
+import { Isometry } from "../../math/isometry";
+import { squared } from "../../math/scalar";
+import { Vec3 } from "../../math/vec3";
+import { Body } from "../../physics/Body";
+import { Sphere } from "../../shape/Sphere";
+import { PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { CollisionCollector, CollisionResult, CollisionSettings } from "./collide";
+
+const result = CollisionResult.create({
+  faceA: {
+    numVertices: 0,
+    buffer: { pool: new Vec3.Pool(32), maxLength: 32 },
+  },
+  faceB: {
+    numVertices: 0,
+    buffer: { pool: new Vec3.Pool(32), maxLength: 32 },
+  },
+});
+
+const positionA = /*@__PURE__*/ Vec3.create();
+const positionB = /*@__PURE__*/ Vec3.create();
+const ab = /*@__PURE__*/ Vec3.create();
+
+// TODO: use settings
+// TODO: use initialDirection
+export function collideSphereVsSphere(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: Sphere,
+  shapeB: Sphere,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+) {
+  result.reset();
+  // @ts-ignore
+  result.bodyA = bodyA;
+  // @ts-ignore
+  result.bodyB = bodyB;
+
+  // get positions
+  isometryA.matrix.getTranslation(positionA);
+  isometryB.matrix.getTranslation(positionB);
+
+  // get distance
+  ab.subtractVectors(positionB, positionA);
+
+  // exit if no contact
+  if (ab.squaredLength() > squared(shapeA.radius + shapeB.radius)) {
+    result.hasContact = false;
+    collector.addMiss();
+    return;
+  }
+
+  // set results
+  result.hasContact = true;
+  // @ts-ignore
+  result.bodyA = bodyA;
+  // @ts-ignore
+  result.bodyB = bodyB;
+  result.subShapeIdA = subShapeIdA;
+  result.subShapeIdB = subShapeIdB;
+  result.normalA.normalizeVector(ab);
+  result.normalB.negateVector(result.normalA);
+  result.contactPointA.addScaledToVector(positionA, result.normalA, shapeA.radius);
+  result.contactPointB.addScaledToVector(positionB, result.normalB, shapeB.radius);
+  result.momentArmA.subtractVectors(result.contactPointA, positionA);
+  result.momentArmB.subtractVectors(result.contactPointB, positionB);
+  result.penetration = shapeA.radius + shapeB.radius - ab.length();
+
+  // normalize the normals
+  result.normalA.normalizeVector(result.normalA);
+  result.normalB.normalizeVector(result.normalB);
+
+  collector.addHit(result);
+}

package/src/collision/collide/collideTriangleMeshVsCompound.ts

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

package/src/collision/collide/collideTriangleMeshVsConvex.ts

@@ -0,0 +1,58 @@
+import { Isometry } from "../../math/isometry";
+import { Aabb } from "../../shape/Aabb";
+import { ConvexShape } from "../../shape/Shape";
+import { PenetrationDepthModule } from "../gjk/PenetrationDepthModule";
+import { ActiveEdgeMode, BackFaceMode, CollectFacesMode, CollisionCollector, CollisionSettings } from "./collide";
+import { TriangleMesh } from "../../shape/TriangleMesh";
+import { Triangle } from "../../shape/Triangle";
+import { TriangleCollider2 } from "../TriangleCollider2";
+import { Body } from "../../physics/Body";
+import { Vec3 } from "../../math/vec3";
+
+const isometryWorldToA = /*@__PURE__*/ Isometry.create();
+const isometryBToA = /*@__PURE__*/ Isometry.create();
+const shapeBBoundsInASpace = /*@__PURE__*/ Aabb.create();
+const triangleCollider = /*@__PURE__*/ new TriangleCollider2();
+
+function onHit(triangle: Triangle): boolean {
+  triangleCollider.collide(triangle, triangle.activeEdges, triangle.subShapeId, undefined, undefined, true);
+  return false;
+}
+
+export function collideTriangleMeshVsConvex(
+  penetrationDepthModule: PenetrationDepthModule,
+  collector: CollisionCollector,
+  shapeA: TriangleMesh,
+  shapeB: ConvexShape,
+  isometryA: Isometry,
+  isometryB: Isometry,
+  settings: CollisionSettings,
+  bodyA: Body | null,
+  bodyB: Body | null,
+  initialDirection?: Vec3,
+  subShapeIdA: number = 0,
+  subShapeIdB: number = 0
+): void {
+  // TODO: don't hardcode this option
+  settings.backFaceMode = BackFaceMode.IgnoreBackFaces;
+  settings.collectFacesMode = CollectFacesMode.CollectFaces;
+  settings.activeEdgeMode = ActiveEdgeMode.CollideWithAll;
+
+  triangleCollider.initialize(
+    penetrationDepthModule,
+    shapeB,
+    isometryB,
+    isometryA,
+    settings,
+    collector,
+    subShapeIdB,
+    bodyB,
+    bodyA
+  );
+  isometryWorldToA.matrix.invertMatrix(isometryA.matrix);
+  isometryBToA.matrix.multiplyMatrices(isometryWorldToA.matrix, isometryB.matrix);
+  shapeBBoundsInASpace.copy(shapeB.computedAabb);
+  shapeBBoundsInASpace.transform(isometryBToA);
+  shapeBBoundsInASpace.expand(settings.maxSeparation);
+  shapeA.bvh!.intersectAabb(onHit, shapeBBoundsInASpace);
+}