@perplexdotgg/bounce 1.0.0

package/src/collision/TriangleCollider.ts

@@ -0,0 +1,308 @@
+import { Isometry } from "../math/isometry";
+import { Mat3 } from "../math/mat3";
+import { Vec3 } from "../math/vec3";
+import { Face } from "../physics/manifold/Face";
+import { Aabb } from "../shape/Aabb";
+import { ConvexRadiusObject, SupportMode } from "../shape/Convex";
+import { ConvexShape } from "../shape/Shape";
+import { Triangle } from "../shape/Triangle";
+import { fixNormal } from "./activeEdge";
+import { PenetrationDepth, PenetrationDepthModule } from "./gjk/PenetrationDepthModule";
+import {
+  ActiveEdgeMode,
+  BackFaceMode,
+  CollisionCollector,
+  CollisionResult,
+  CollisionSettings,
+  CollisionStatus,
+} from "./collide/collide";
+import { Body } from "../physics/Body";
+
+const result = /*@__PURE__*/ 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 isometryBToA = /*@__PURE__*/ Isometry.create();
+const localBoundsA = /*@__PURE__*/ Aabb.create();
+const shapeB = /*@__PURE__*/ Triangle.create();
+const convexA = /*@__PURE__*/ ConvexRadiusObject.create();
+const convexB = /*@__PURE__*/ ConvexRadiusObject.create();
+const rotationMatrixA = /*@__PURE__*/ Mat3.create();
+const positionA = /*@__PURE__*/ Vec3.create();
+const positionB = /*@__PURE__*/ Vec3.create();
+
+const triangleNormal = /*@__PURE__*/ Vec3.create();
+const triangleBounds = /*@__PURE__*/ Aabb.create();
+const pointA = /*@__PURE__*/ Vec3.create();
+const pointB = /*@__PURE__*/ Vec3.create();
+const penetrationAxis = /*@__PURE__*/ Vec3.create();
+const gjkResult = /*@__PURE__*/ PenetrationDepth.create();
+const pointAB = /*@__PURE__*/ Vec3.create();
+const activeEdgeMovementDirectionWorld = /*@__PURE__*/ Vec3.create();
+const activeEdgeMovementDirectionLocal = /*@__PURE__*/ Vec3.create();
+const contactNormal = /*@__PURE__*/ Vec3.create();
+const negatedPenetrationAxis = /*@__PURE__*/ Vec3.create();
+const negatedTriangleNormal = /*@__PURE__*/ Vec3.create();
+const penetrationAxisWorld = /*@__PURE__*/ Vec3.create();
+
+export class TriangleCollider {
+  declare penetrationDepthModule: PenetrationDepthModule;
+  declare shapeA: ConvexShape;
+  declare shapeB: Triangle;
+  declare isometryA: Isometry;
+  declare isometryB: Isometry;
+  declare settings: CollisionSettings;
+  declare collector: CollisionCollector;
+  declare subShapeAId: number;
+  bodyA: Body | null = null;
+  bodyB: Body | null = null;
+
+  initialize(
+    penetrationDepthModule: PenetrationDepthModule,
+    shapeA: ConvexShape,
+    isometryA: Isometry,
+    isometryB: Isometry,
+    settings: CollisionSettings,
+    collector: CollisionCollector,
+    subShapeAId: number = 0,
+    bodyA: Body | null = null,
+    bodyB: Body | null = null
+  ): void {
+    this.penetrationDepthModule = penetrationDepthModule;
+    this.shapeA = shapeA;
+    this.isometryA = isometryA;
+    this.isometryB = isometryB;
+    this.settings = settings;
+    this.collector = collector;
+    this.subShapeAId = subShapeAId;
+    this.bodyA = bodyA;
+    this.bodyB = bodyB;
+
+    // get the isometry from B to A
+    isometryBToA.matrix.invertMatrix(isometryA.matrix);
+    isometryBToA.matrix.multiplyMatrix(isometryB.matrix);
+
+    // get the rotation matrix of A
+    rotationMatrixA.fromMat4(isometryA.matrix);
+
+    // get the positions
+    isometryA.matrix.getTranslation(positionA);
+    isometryB.matrix.getTranslation(positionB);
+
+    // get the local bounds of A
+    localBoundsA.copy(shapeA.computedAabb);
+    localBoundsA.expand(settings.maxSeparation);
+  }
+
+  collide(triangle: Triangle, activeEdges: number, triangleId: number, bodyA?: Body | null, bodyB?: Body | null): void {
+    result.reset();
+    // @ts-ignore
+    result.bodyA = bodyA || this.bodyA;
+    // @ts-ignore
+    result.bodyB = bodyB || this.bodyB;
+    const settings = this.settings;
+    const shapeA = this.shapeA;
+    const isometryA = this.isometryA;
+    const subShapeAId = this.subShapeAId;
+    const collector = this.collector;
+    const penetrationDepthModule = this.penetrationDepthModule;
+
+    // get the triangle in A space
+    shapeB.copy(triangle);
+    shapeB.transform(isometryBToA.matrix);
+
+    // get the triangle normal
+
+    shapeB.computeNormal(triangleNormal);
+    // shapeB.getUnnormalizedNormal(triangleNormal);
+
+    // TODO: handle backface mode
+    const back_facing = triangleNormal.dot(triangle.a) > 0;
+    if (settings.backFaceMode === BackFaceMode.IgnoreBackFaces && back_facing) {
+      // console.log("miss: ignoring back-facing triangle");
+      collector.addMiss();
+      return;
+    }
+
+    // get triangle bounds
+
+    shapeB.computeLocalBounds(triangleBounds);
+
+    // collide bounds
+    if (localBoundsA.intersectsAabb(triangleBounds) === false) {
+      // console.log("miss: bounds do not intersect");
+      collector.addMiss();
+      return;
+    }
+
+    // get the support shapes
+    const supportA = shapeA.computeSupportShape(SupportMode.ExcludeConvexRadius, 1);
+    const supportB = shapeB.computeSupportShape(SupportMode.ExcludeConvexRadius, 1);
+
+    // get convex radii, including the max separation distance
+    const convexRadiusA = supportA.getConvexRadius() + settings.maxSeparation;
+    const convexRadiusB = supportB.getConvexRadius();
+
+    // init the pass-through results
+
+    // init the penetration axis as the triangle normal
+    penetrationAxis.negateVector(triangleNormal);
+
+    // init the gjk result
+
+    // run gjk
+    penetrationDepthModule.getPenetrationDepthStepGjk(
+      gjkResult,
+      supportA,
+      supportB,
+      convexRadiusA,
+      convexRadiusB,
+      penetrationAxis,
+      settings.collisionTolerance
+    );
+
+    switch (gjkResult.status) {
+      case CollisionStatus.Colliding: {
+        // pass through the results
+        pointA.copy(gjkResult.pointA);
+        pointB.copy(gjkResult.pointB);
+        penetrationAxis.copy(gjkResult.penetrationAxis);
+        break;
+      }
+
+      case CollisionStatus.NotColliding: {
+        // definitive no penetration
+        result.hasContact = false;
+        // console.log("miss: no hit from gjk");
+        collector.addMiss();
+        return;
+      }
+
+      case CollisionStatus.Indeterminate: {
+        // need to run IMP
+
+        // get the support shapes
+        const supportA = shapeA.computeSupportShape(SupportMode.IncludeConvexRadius, 1);
+        const supportB = shapeB.computeSupportShape(SupportMode.IncludeConvexRadius, 1);
+
+        // // get the convex shapes
+        // convexA.object = supportA;
+        // convexA.radius = settings.maxSeparation;
+
+        // convexB.object = supportB;
+        // convexB.radius = 0;
+        convexA.setData(settings.maxSeparation, supportA);
+        convexB.setData(0, supportB);
+
+        // init the imp result
+
+        const hitFound = penetrationDepthModule.getPenetrationDepthStepEPA(
+          convexA,
+          convexB,
+          settings.collisionTolerance,
+          penetrationAxis,
+          pointA,
+          pointB
+        );
+
+        if (!hitFound) {
+          // console.log("miss: no hit from EPA");
+          result.hasContact = false;
+          collector.addMiss();
+          return;
+        }
+      }
+    }
+
+    // we have a collision
+
+    // get the penetration depth
+
+    // check if penetration is bigger than early out fraction
+    pointAB.subtractVectors(pointB, pointA);
+    const penetrationDepth = pointAB.length() - settings.maxSeparation;
+    if (-penetrationDepth >= collector.getEarlyOutFraction()) {
+      result.hasContact = false;
+      collector.addMiss();
+      return;
+    }
+
+    // reduce pointA by the max separation distance along the penetration axis
+    const penetrationAxisLength = penetrationAxis.length();
+    if (penetrationAxisLength > 0) {
+      pointA.addScaled(penetrationAxis, -(settings.maxSeparation / penetrationAxisLength));
+    }
+
+    // TODO: handle active edge detection
+    if (settings.activeEdgeMode === ActiveEdgeMode.CollideOnlyWithActive && activeEdges !== 0b111) {
+      activeEdgeMovementDirectionWorld.x = settings.activeEdgeMovementDirectionX;
+      activeEdgeMovementDirectionWorld.y = settings.activeEdgeMovementDirectionY;
+      activeEdgeMovementDirectionWorld.z = settings.activeEdgeMovementDirectionZ;
+
+      // convert the active edge velocity hint to local space
+      isometryA.matrix.multiply3x3Transposed(activeEdgeMovementDirectionLocal, activeEdgeMovementDirectionWorld);
+
+      // update the penetration axis to account for active edges
+      // note that we flip the triangle normal as the penetration axis is pointing towards the triangle instead of away
+      negatedPenetrationAxis.negateVector(penetrationAxis);
+      negatedTriangleNormal.negateVector(triangleNormal);
+
+      fixNormal(
+        contactNormal,
+        shapeB.a,
+        shapeB.b,
+        shapeB.c,
+        // back_facing ? triangleNormal : negatedTriangleNormal,
+        // triangleNormal,
+        negatedTriangleNormal,
+        activeEdges,
+        pointB,
+        penetrationAxis,
+        activeEdgeMovementDirectionLocal
+      );
+
+      // update the penetration axis
+      penetrationAxis.copy(contactNormal);
+    }
+
+    // convert results from A space to world space
+    result.hasContact = true;
+    result.subShapeIdA = subShapeAId;
+    result.subShapeIdB = triangleId;
+    result.isBackFace = back_facing;
+
+    // convert to world space
+    pointA.transformByMat4(isometryA.matrix);
+    pointB.transformByMat4(isometryA.matrix);
+    isometryA.matrix.multiply3x3(penetrationAxisWorld, penetrationAxis);
+
+    result.contactPointA.copy(pointA);
+    result.contactPointB.copy(pointB);
+
+    // get the normal in world space
+    result.normalA.copy(penetrationAxisWorld);
+    result.normalB.negateVector(result.normalA);
+
+    result.penetration = penetrationDepth;
+    result.hasContact = true;
+
+    // add the world space surface normal of the triangle
+    result.surfaceNormalA.zero();
+    result.surfaceNormalB.transformVectorFromMat3(triangleNormal, rotationMatrixA);
+
+    // normalize the normals
+    result.normalA.normalize();
+    result.normalB.normalize();
+
+    // console.log("hit: triangle collider hit");
+
+    // add the hit
+    collector.addHit(result);
+  }
+}

package/src/collision/TriangleCollider2.ts

@@ -0,0 +1,379 @@
+import { Isometry } from "../math/isometry";
+import { Mat3 } from "../math/mat3";
+import { Vec3 } from "../math/vec3";
+import { Face } from "../physics/manifold/Face";
+import { Aabb } from "../shape/Aabb";
+import { ConvexRadiusObject, SupportMode } from "../shape/Convex";
+import { ConvexShape } from "../shape/Shape";
+import { Triangle } from "../shape/Triangle";
+import { fixNormal } from "./activeEdge";
+import { PenetrationDepth, PenetrationDepthModule } from "./gjk/PenetrationDepthModule";
+import {
+  ActiveEdgeMode,
+  BackFaceMode,
+  CollectFacesMode,
+  CollisionCollector,
+  CollisionResult,
+  CollisionSettings,
+  CollisionStatus,
+} from "./collide/collide";
+import { Body } from "../physics/Body";
+
+const result = /*@__PURE__*/ 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 isometryBToA = /*@__PURE__*/ Isometry.create();
+const localBoundsA = /*@__PURE__*/ Aabb.create();
+const shapeB = /*@__PURE__*/ Triangle.create();
+const convexA = /*@__PURE__*/ ConvexRadiusObject.create();
+const convexB = /*@__PURE__*/ ConvexRadiusObject.create();
+const rotationMatrixA = /*@__PURE__*/ Mat3.create();
+const positionA = /*@__PURE__*/ Vec3.create();
+const positionB = /*@__PURE__*/ Vec3.create();
+
+const centerA = /*@__PURE__*/ Vec3.create();
+const centerB = /*@__PURE__*/ Vec3.create();
+
+const triangleNormal = /*@__PURE__*/ Vec3.create();
+const triangleBounds = /*@__PURE__*/ Aabb.create();
+const pointA = /*@__PURE__*/ Vec3.create();
+const pointB = /*@__PURE__*/ Vec3.create();
+const penetrationAxis = /*@__PURE__*/ Vec3.create();
+const gjkResult = /*@__PURE__*/ PenetrationDepth.create();
+const pointAB = /*@__PURE__*/ Vec3.create();
+const activeEdgeMovementDirectionWorld = /*@__PURE__*/ Vec3.create();
+const activeEdgeMovementDirectionLocal = /*@__PURE__*/ Vec3.create();
+const contactNormal = /*@__PURE__*/ Vec3.create();
+const negatedPenetrationAxis = /*@__PURE__*/ Vec3.create();
+const negatedTriangleNormal = /*@__PURE__*/ Vec3.create();
+const penetrationAxisWorld = /*@__PURE__*/ Vec3.create();
+
+export class TriangleCollider2 {
+  declare penetrationDepthModule: PenetrationDepthModule;
+  declare shapeA: ConvexShape;
+  declare shapeB: Triangle;
+  declare isometryA: Isometry;
+  declare isometryB: Isometry;
+  declare settings: CollisionSettings;
+  declare collector: CollisionCollector;
+  declare subShapeAId: number;
+  bodyA: Body | null = null;
+  bodyB: Body | null = null;
+
+  initialize(
+    penetrationDepthModule: PenetrationDepthModule,
+    shapeA: ConvexShape,
+    isometryA: Isometry,
+    isometryB: Isometry,
+    settings: CollisionSettings,
+    collector: CollisionCollector,
+    subShapeAId: number = 0,
+    bodyA: Body | null = null,
+    bodyB: Body | null = null
+  ): void {
+    this.penetrationDepthModule = penetrationDepthModule;
+    this.shapeA = shapeA;
+    this.isometryA = isometryA;
+    this.isometryB = isometryB;
+    this.settings = settings;
+    this.collector = collector;
+    this.subShapeAId = subShapeAId;
+    this.bodyA = bodyA;
+    this.bodyB = bodyB;
+
+    // console.log(isometryA.matrix.toObject());
+    // console.log(isometryB.matrix.toObject());
+    // console.log(settings);
+    // console.log(subShapeAId);
+
+    // get the isometry from B to A
+    isometryBToA.matrix.invertMatrix(isometryA.matrix);
+    isometryBToA.matrix.multiplyMatrices(isometryBToA.matrix, isometryB.matrix);
+    // isometryBToA.matrix.log("isometryBToA");
+
+    // get the rotation matrix of A
+    rotationMatrixA.fromMat4(isometryA.matrix);
+
+    // get the positions
+    isometryA.matrix.getTranslation(positionA);
+    isometryB.matrix.getTranslation(positionB);
+
+    // get the local bounds of A
+    localBoundsA.copy(shapeA.computedAabb);
+    localBoundsA.expand(settings.maxSeparation);
+  }
+
+  collide(
+    triangle: Triangle,
+    activeEdges: number,
+    triangleId: number,
+    bodyA: Body | null = null,
+    bodyB: Body | null = null,
+    swapResults: boolean = false
+  ): void {
+    result.reset();
+    // @ts-ignore
+    result.bodyA = bodyA || this.bodyA;
+    // @ts-ignore
+    result.bodyB = bodyB || this.bodyB;
+    const settings = this.settings;
+    const shapeA = this.shapeA;
+    const isometryA = this.isometryA;
+    const subShapeAId = this.subShapeAId;
+    const collector = this.collector;
+    const penetrationDepthModule = this.penetrationDepthModule;
+
+    // get the triangle in A space
+    shapeB.copy(triangle);
+    shapeB.transform(isometryBToA.matrix);
+    // console.log(triangleId, triangle.toObject(), shapeB.toObject());
+
+    // get the triangle normal
+    shapeB.computeUnnormalizedNormal(triangleNormal);
+    // shapeB.getNormal(triangleNormal);
+
+    // TODO: handle backface mode
+    // const back_facing = triangleNormal.dot(triangle.a) > 0;
+    const back_facing = triangleNormal.dot(shapeB.a) > 0;
+    if (settings.backFaceMode === BackFaceMode.IgnoreBackFaces && back_facing) {
+      // this.world.debug && console.log("triangle miss, ignore back faces", triangleId);
+      // console.log("miss: ignoring back-facing triangle");
+      collector.addMiss();
+      return;
+    }
+
+    // get triangle bounds
+    shapeB.computeLocalBounds(triangleBounds);
+
+    // collide bounds
+    if (localBoundsA.intersectsAabb(triangleBounds) === false) {
+      // this.world.debug && console.log("triangle miss, bounds not intersecting", triangleId);
+      // console.log("miss: bounds do not intersect");
+      collector.addMiss();
+      // console.log("exit because bounds don't overlap");
+      return;
+    }
+
+    // get the support shapes
+    const supportA = shapeA.computeSupportShape(SupportMode.ExcludeConvexRadius, 1);
+    const supportB = shapeB.computeSupportShape(SupportMode.ExcludeConvexRadius, 1);
+
+    // init the pass-through results
+    // init the penetration axis as the triangle normal
+    // vec3.negate(penetrationAxis, triangleNormal);
+
+    // penetrationAxis.set([0, +1, 0]);
+
+    isometryA.matrix.getTranslation(centerA);
+    shapeB.computeCentroid(centerB);
+    penetrationAxis.subtractVectors(centerB, centerA);
+
+    penetrationAxis.normalize();
+
+    // init the gjk result
+    // run gjk
+    // if (this.world.debug) {
+    //   debugger;
+    // }
+    penetrationDepthModule.getPenetrationDepthStepGjk(
+      gjkResult,
+      supportA,
+      supportB,
+      supportA.getConvexRadius() + settings.maxSeparation,
+      supportB.getConvexRadius(),
+      penetrationAxis,
+      settings.collisionTolerance
+    );
+
+    switch (gjkResult.status) {
+      case CollisionStatus.Colliding: {
+        // pass through the results
+        pointA.copy(gjkResult.pointA);
+        pointB.copy(gjkResult.pointB);
+        penetrationAxis.copy(gjkResult.penetrationAxis);
+        // console.log("found collision with gjk");
+        break;
+      }
+
+      case CollisionStatus.NotColliding: {
+        // this.world.debug && console.log("triangle miss, not colliding via gjk", triangleId);
+        // definitive no penetration
+        // console.log("miss: no hit from gjk");
+        collector.addMiss();
+        // console.log("exit because gjk says not colliding");
+        return;
+      }
+
+      case CollisionStatus.Indeterminate: {
+        // console.log("starting imp");
+        // need to run IMP
+
+        // get the support shapes
+        const supportA = shapeA.computeSupportShape(SupportMode.IncludeConvexRadius, 1);
+        const supportB = shapeB.computeSupportShape(SupportMode.IncludeConvexRadius, 1);
+
+        // get the convex shapes
+        // const convexA = this.convexA;
+        // convexA.object = supportA;
+        // convexA.radius = settings.maxSeparation;
+
+        // const convexB = this.convexB;
+        // convexB.object = supportB;
+        // convexB.radius = 0;
+
+        convexA.setData(settings.maxSeparation, supportA);
+        convexB.setData(0, supportB);
+
+        const hitFound = penetrationDepthModule.getPenetrationDepthStepEPA(
+          convexA,
+          convexB,
+          settings.collisionTolerance,
+          penetrationAxis,
+          pointA,
+          pointB
+        );
+
+        if (!hitFound) {
+          result.hasContact = false;
+          collector.addMiss();
+          return;
+        }
+      }
+    }
+
+    // we have a collision
+
+    // // check if penetration axis is similar to triangle normal, if it is, negate it to make it consistent whether back-facing or not
+    // if (penetrationAxis.dot(triangleNormal) > 0) {
+    //   vec3.negate(penetrationAxis, penetrationAxis);
+    // }
+
+    // if (this.world.debugger) {
+    //   this.world.debugger.drawShape({
+    //     type: "arrow",
+    //     group: "foo",
+    //     origin: pointA,
+    //     direction: penetrationAxis,
+    //     length: 10,
+    //     radius: 0.1,
+    //     color: "black",
+    //   });
+    // }
+
+    // check if penetration is bigger than early out fraction
+    pointAB.subtractVectors(pointB, pointA);
+    const penetrationDepth = pointAB.length() - settings.maxSeparation;
+    if (-penetrationDepth >= collector.getEarlyOutFraction()) {
+      result.hasContact = false;
+      collector.addMiss();
+      return;
+    }
+
+    // reduce pointA by the max separation distance along the penetration axis
+    const penetrationAxisLength = penetrationAxis.length();
+    if (penetrationAxisLength > 0) {
+      pointA.addScaled(penetrationAxis, -(settings.maxSeparation / penetrationAxisLength));
+    }
+
+    // TODO: handle active edge detection
+    if (settings.activeEdgeMode === ActiveEdgeMode.CollideOnlyWithActive && activeEdges !== 0b111) {
+      activeEdgeMovementDirectionWorld.x = settings.activeEdgeMovementDirectionX;
+      activeEdgeMovementDirectionWorld.y = settings.activeEdgeMovementDirectionY;
+      activeEdgeMovementDirectionWorld.z = settings.activeEdgeMovementDirectionZ;
+
+      // convert the active edge velocity hint to local space
+      isometryA.matrix.multiply3x3Transposed(activeEdgeMovementDirectionLocal, activeEdgeMovementDirectionWorld);
+
+      // update the penetration axis to account for active edges
+      // note that we flip the triangle normal as the penetration axis is pointing towards the triangle instead of away
+      negatedPenetrationAxis.negateVector(penetrationAxis);
+      negatedTriangleNormal.negateVector(triangleNormal);
+
+      fixNormal(
+        contactNormal,
+        shapeB.a,
+        shapeB.b,
+        shapeB.c,
+        // back_facing ? triangleNormal : negatedTriangleNormal,
+        // triangleNormal,
+        negatedTriangleNormal,
+        activeEdges,
+        pointB,
+        penetrationAxis,
+        activeEdgeMovementDirectionLocal
+      );
+
+      // update the penetration axis
+      penetrationAxis.copy(contactNormal);
+    }
+
+    // convert results from A space to world space
+    result.hasContact = true;
+    result.subShapeIdA = subShapeAId;
+    result.subShapeIdB = triangleId;
+    result.isBackFace = back_facing;
+
+    // this.faceA.clear();
+    // this.faceB.clear();
+    // result.faceA = this.faceA;
+    // result.faceB = this.faceB;
+
+    // if (settings.collectFacesMode === CollectFacesMode.CollectFaces) {
+    //   // const negatedPenetrationAxis = Vec3.global(
+    //   //   this.world,
+    //   //   "CollideConvexAndTriangles2.collide.negatedPenetrationAxis"
+    //   // );
+    //   negatedPenetrationAxis.negateVector(penetrationAxis);
+    //   shapeA.computeSupportingFace(result.faceA, subShapeAId, negatedPenetrationAxis, 1, isometryA.matrix);
+    //   shapeB.computeSupportingFace(result.faceB, triangleId, negatedPenetrationAxis, 1, isometryA.matrix);
+    // }
+
+    // convert to world space
+    pointA.transformByMat4(isometryA.matrix);
+    pointB.transformByMat4(isometryA.matrix);
+    isometryA.matrix.multiply3x3(penetrationAxisWorld, penetrationAxis);
+
+    result.contactPointA.copy(pointA);
+    result.contactPointB.copy(pointB);
+
+    // get the normal in world space
+    result.normalA.copy(penetrationAxisWorld);
+    result.normalB.negateVector(result.normalA);
+
+    result.penetration = penetrationDepth;
+    result.hasContact = true;
+
+    // add the world space surface normal of the triangle
+    result.surfaceNormalA.zero();
+    result.surfaceNormalB.transformVectorFromMat3(triangleNormal, rotationMatrixA);
+
+    // normalize the normals
+    result.normalA.normalize();
+    result.normalB.normalize();
+
+    // console.log("collision found: processed results");
+    // console.log("result.contactPointA", result.contactPointA.toArray());
+    // console.log("result.contactPointB", result.contactPointB.toArray());
+    // console.log("result.normalA", result.normalA.toArray());
+    // console.log("result.penetration", result.penetration);
+    // result.faceA.log("result.faceA");
+    // result.faceB.log("result.faceB");
+
+    if (swapResults) {
+      result.swap();
+    }
+
+    // console.log("hit: triangle collider hit");
+
+    // add the hit
+    // this.world.debug && console.log("triangle hit", triangleId);
+    collector.addHit(result);
+  }
+}