@perplexdotgg/bounce 1.0.0 → 1.0.1

package/src/physics/manifold/ContactManifoldModule.ts

@@ -1,623 +0,0 @@
-import { createClass, NumberType, ReferenceListType, PropertyDefinitionMap, NumberArray, PoolClass } from "monomorph";
-import { Quat } from "../../math/quat";
-import { degreesToRadians, squared } from "../../math/scalar";
-import { Vec3 } from "../../math/vec3";
-import { Body, BodyType } from "../Body";
-import { clipPolyVsEdge } from "./clipping/clipPolyVsEdge";
-import { clipPolyVsPoly } from "./clipping/clipPolyVsPoly";
-import { ContactManifold, ContactManifoldPool, createContactPairKey } from "./ContactManifold";
-import { ContactPair } from "./ContactManifold";
-import { Face } from "./Face";
-import { ManifoldCache, ManifoldCacheOptions } from "./ManifoldCache";
-import { Mat4 } from "../../math/mat4";
-import { ContactConstraintModule } from "../solver/ContactConstraintModule";
-import { SleepModule } from "../SleepModule";
-
-const contactPairCacheMaxDeltaPositionSquared = squared(0.001); // < 1mm
-const contactPairCacheCosMaxDeltaRotationDiv2 = Math.cos(degreesToRadians(2) / 2);
-const negatedPenetrationAxis = /*@__PURE__*/ Vec3.create();
-
-const vec3BufferProps = {
-  numItems: NumberType(0),
-  vec3List: ReferenceListType(Vec3),
-} as const satisfies PropertyDefinitionMap;
-
-export class Vec3Buffer extends createClass<Vec3Buffer, typeof vec3BufferProps>(vec3BufferProps) {
-  getVec3(out: Vec3, index: number): void {
-    out.copy(this.vec3List!.getAtIndex(index)!);
-  }
-
-  pushVec3(value: Vec3): void {
-    if (this.numItems >= this.vec3List!.maxLength) {
-      throw new Error("Vec3Buffer is full");
-    }
-
-    this.vec3List!.getAtIndex(this.numItems)!.copy(value);
-    this.numItems++;
-  }
-
-  getNumber(index: number) {
-    const vec = this.vec3List!.getAtIndex(index)!;
-    return vec.x;
-  }
-
-  pushNumber(value: number) {
-    if (this.numItems >= this.vec3List!.maxLength) {
-      throw new Error("Vec3Buffer is full");
-    }
-
-    const vec = this.vec3List!.getAtIndex(this.numItems)!;
-    vec.x = value;
-    this.numItems++;
-  }
-
-  clear(): void {
-    this.numItems = 0;
-  }
-}
-
-const oldCreate = Vec3Buffer.create;
-Vec3Buffer.create = function () {
-  const vec3Buffer = oldCreate.apply(this, arguments as any);
-
-  // todo this behavior probably should change?
-  // currently, we create all the contactConstraints once the first time, and never destroy them.
-  // they technically should be destroyed, but this is more efficient for this use case
-  // since we will be reusing the same manifolds over and over again, so we should just
-  // increment a numManifolds instead that is reset to 0
-  if (vec3Buffer.vec3List.length >= vec3Buffer.vec3List!.maxLength) {
-    return vec3Buffer;
-  }
-
-  for (let i = 0; i < vec3Buffer.vec3List!.maxLength; i++) {
-    vec3Buffer.vec3List!.create();
-  }
-
-  return vec3Buffer;
-};
-
-const clippedFace = /*@__PURE__*/ Face.create({
-  numVertices: 0,
-    buffer: { pool: new Vec3.Pool(32), maxLength: 32 },
-});
-
-const bodyAInverseOrientation = /*@__PURE__*/ Quat.create();
-
-const edgeVertex1 = /*@__PURE__*/ Vec3.create();
-const edgeVertex2 = /*@__PURE__*/ Vec3.create();
-const planeOrigin = /*@__PURE__*/ Vec3.create();
-const planeNormal = /*@__PURE__*/ Vec3.create();
-const firstEdge = /*@__PURE__*/ Vec3.create();
-const secondEdge = /*@__PURE__*/ Vec3.create();
-const perpendicular = /*@__PURE__*/ Vec3.create();
-const p2 = /*@__PURE__*/ Vec3.create();
-const vectorAB = /*@__PURE__*/ Vec3.create();
-const p1 = /*@__PURE__*/ Vec3.create();
-
-const projected = /*@__PURE__*/ Vec3Buffer.create({
-  numItems: 0,
-  vec3List: { pool: new Vec3.Pool(64), maxLength: 64 },
-});
-
-const penetrationDepthSq = /*@__PURE__*/ Vec3Buffer.create({
-  numItems: 0,
-  vec3List: { pool: new Vec3.Pool(64), maxLength: 64 },
-});
-
-const pointsToKeepOnA = /*@__PURE__*/ Vec3Buffer.create({
-  numItems: 0,
-  vec3List: { pool: new Vec3.Pool(4), maxLength: 4 },
-});
-
-const pointsToKeepOnB = /*@__PURE__*/ Vec3Buffer.create({
-  numItems: 0,
-  vec3List: { pool: new Vec3.Pool(4), maxLength: 4 },
-});
-
-const v1 = /*@__PURE__*/ Vec3.create();
-const projectedPoint = /*@__PURE__*/ Vec3.create();
-const v2 = /*@__PURE__*/ Vec3.create();
-const vector12 = /*@__PURE__*/ Vec3.create();
-const currentProjectedPoint = /*@__PURE__*/ Vec3.create();
-const point1v = /*@__PURE__*/ Vec3.create();
-const differenceVector = /*@__PURE__*/ Vec3.create();
-const point2v = /*@__PURE__*/ Vec3.create();
-const perp = /*@__PURE__*/ Vec3.create();
-const vectorPoint1vToPoint2v = /*@__PURE__*/ Vec3.create();
-const tempPointA = /*@__PURE__*/ Vec3.create();
-const tempPointB = /*@__PURE__*/ Vec3.create();
-
-const inverseOrientationA = /*@__PURE__*/ Quat.create();
-const translationAB = /*@__PURE__*/ Vec3.create();
-const rotationAB = /*@__PURE__*/ Quat.create();
-const localToWorldA = /*@__PURE__*/ Mat4.create();
-const localToWorldB = /*@__PURE__*/ Mat4.create();
-const localPointA = /*@__PURE__*/ Vec3.create();
-const localPointB = /*@__PURE__*/ Vec3.create();
-const worldPointA = /*@__PURE__*/ Vec3.create();
-const worldPointB = /*@__PURE__*/ Vec3.create();
-const vectorBA = /*@__PURE__*/ Vec3.create();
-
-const tempManifoldPool = /*@__PURE__*/ new ContactManifoldPool(1, 4);
-const tempManifold = /*@__PURE__*/ tempManifoldPool.createContactManifold({
-  bodyA: null,
-  bodyB: null,
-  subShapeIdA: 0,
-  subShapeIdB: 0,
-  nextContactManifold: null,
-
-  baseTranslation: { x: 0, y: 0, z: 0 },
-  firstWorldSpaceNormal: { x: 0, y: 0, z: 0 },
-  worldSpaceNormal: { x: 0, y: 0, z: 0 },
-  penetrationDepth: 0,
-  numContacts: 0,
-});
-
-export class ContactManifoldModule {
-  manifoldCaches: [ManifoldCache, ManifoldCache];
-  currentManifoldCacheIndex: number;
-
-  constructor(options?: Partial<ManifoldCacheOptions>) {
-    this.manifoldCaches = [new ManifoldCache(options), new ManifoldCache(options)];
-    this.currentManifoldCacheIndex = 0;
-  }
-
-  get currentManifoldCache() {
-    return this.manifoldCaches[this.currentManifoldCacheIndex];
-  }
-
-  get previousManifoldCache() {
-    return this.manifoldCaches[1 - this.currentManifoldCacheIndex];
-  }
-
-  toArray(array: NumberArray, startOffset: number): number {
-    array[startOffset++] = this.currentManifoldCacheIndex;
-    startOffset = this.manifoldCaches[0].toArray(array, startOffset);
-    startOffset = this.manifoldCaches[1].toArray(array, startOffset);
-    return startOffset;
-  }
-
-  fromArray(
-    array: NumberArray,
-    references: {
-      body: PoolClass<Body>;
-    },
-    startOffset: number
-  ): number {
-    this.currentManifoldCacheIndex = array[startOffset++];
-    startOffset = this.manifoldCaches[0].fromArray(array, references, startOffset);
-    startOffset = this.manifoldCaches[1].fromArray(array, references, startOffset);
-    return startOffset;
-  }
-
-  addContactPair(bodyA: Body, bodyB: Body): ContactPair {
-    const pair = ContactPair.create(
-      {
-        bodyA: bodyA,
-        bodyB: bodyB,
-        translationAB: { x: 0, y: 0, z: 0 },
-        rotationAB: { x: 0, y: 0, z: 0, w: 1 },
-      },
-      this.currentManifoldCache.pairs
-    );
-
-    // add the pair to the current manifold cache pair map
-    this.currentManifoldCache.pairMap.set(pair.key, pair);
-
-    // get the quat to transform from World to A space
-
-    bodyAInverseOrientation.conjugateQuat(bodyA.orientation); // we can use the conjugate as the inverse since the quat is normalized
-
-    // get the relative translation from A to B in world space
-    pair.translationAB.subtractVectors(bodyB.computedCenterOfMassPosition, bodyA.computedCenterOfMassPosition);
-
-    // transform it to A space
-    pair.translationAB.transformByQuat(bodyAInverseOrientation);
-
-    // get the relative rotation from A to B in world space
-    pair.rotationAB.multiplyQuats(bodyAInverseOrientation, bodyB.orientation);
-
-    return pair;
-  }
-
-  pruneContactPoints(inPenetrationAxis: Vec3, ioManifold: ContactManifold) {
-    // console.log("\nContactManifoldModule.pruneContactPoints");
-    // #v-ifdef DEV
-    // assert that manifold has more than 4 contact points
-    if (ioManifold.numContacts <= 4) {
-      throw new Error("ContactManifoldModule.pruneContactPoints: manifold must have more than 4 contact points");
-    }
-    // #v-endif
-
-    // #v-ifdef DEV
-    // assert that penetration axis is normalized
-    if (inPenetrationAxis.isNormalized() === false) {
-      throw new Error("ContactManifoldModule.pruneContactPoints: penetrationAxis must be normalized");
-    }
-    // #v-endif
-
-    // We use a heuristic of (distance to center of mass) * (penetration depth) to find the contact point that we should keep
-    // Neither of those two terms should ever become zero, so we clamp against this minimum value
-    const cMinDistanceSq = 1.0e-6; // 1 mm
-
-    projected.clear();
-    penetrationDepthSq.clear();
-
-    for (let i = 0; i < ioManifold.numContacts; i++) {
-      // Project contact points on the plane through inCenterOfMass with normal inPenetrationAxis and center around the center of mass of body 1
-      // (note that since all points are relative to inCenterOfMass we can project onto the plane through the origin)
-
-      ioManifold.getContactPointA(v1, i);
-
-      projectedPoint.addScaledToVector(v1, inPenetrationAxis, -v1.dot(inPenetrationAxis));
-
-      projected.pushVec3(projectedPoint);
-
-      // Calculate penetration depth^2 of each point and clamp against the minimal distance
-
-      ioManifold.getContactPointB(v2, i);
-
-      vector12.subtractVectors(v2, v1);
-
-      penetrationDepthSq.pushNumber(Math.max(cMinDistanceSq, vector12.squaredLength()));
-    }
-
-    // Find the point that is furthest away from the center of mass (its torque will have the biggest influence)
-    // and the point that has the deepest penetration depth. Use the heuristic (distance to center of mass) * (penetration depth) for this.
-    let point1 = 0;
-
-    projected.getVec3(currentProjectedPoint, 0);
-
-    let val = Math.max(cMinDistanceSq, currentProjectedPoint.squaredLength()) * penetrationDepthSq.getNumber(0);
-
-    for (let i = 0; i < projected.numItems; i++) {
-      projected.getVec3(currentProjectedPoint, i);
-      let v = Math.max(cMinDistanceSq, currentProjectedPoint.squaredLength()) * penetrationDepthSq.getNumber(i);
-      if (v > val) {
-        val = v;
-        point1 = i;
-      }
-    }
-
-    projected.getVec3(point1v, point1);
-
-    // Find point furthest from the first point forming a line segment with point1. Again combine this with the heuristic
-    // for deepest point as per above.
-    let point2 = -1;
-    val = -Infinity;
-
-    for (let i = 0; i < projected.numItems; i++) {
-      if (i !== point1) {
-        projected.getVec3(currentProjectedPoint, i);
-
-        differenceVector.subtractVectors(currentProjectedPoint, point1v);
-        let v = Math.max(cMinDistanceSq, differenceVector.squaredLength()) * penetrationDepthSq.getNumber(i);
-
-        if (v > val) {
-          val = v;
-          point2 = i;
-        }
-      }
-    }
-
-    // #v-ifdef DEV
-    // assert that point2 is not -1
-    if (point2 === -1) {
-      throw new Error("ContactManifoldModule.pruneContactPoints: point2 should not be -1");
-    }
-    // #v-endif
-
-    projected.getVec3(point2v, point2);
-
-    // Find furthest points on both sides of the line segment in order to maximize the area
-    let point3 = -1;
-    let point4 = -1;
-    let min_val = 0.0;
-    let max_val = 0.0;
-
-    vectorPoint1vToPoint2v.subtractVectors(point2v, point1v);
-    perp.crossVectors(vectorPoint1vToPoint2v, inPenetrationAxis);
-
-    for (let i = 0; i < projected.numItems; i++) {
-      if (i !== point1 && i !== point2) {
-        projected.getVec3(currentProjectedPoint, i);
-
-        differenceVector.subtractVectors(currentProjectedPoint, point1v);
-        const v = perp.dot(differenceVector);
-
-        if (v < min_val) {
-          min_val = v;
-          point3 = i;
-        } else if (v > max_val) {
-          max_val = v;
-          point4 = i;
-        }
-      }
-    }
-
-    pointsToKeepOnA.clear();
-    pointsToKeepOnB.clear();
-
-    ioManifold.getContactPointA(tempPointA, point1);
-    pointsToKeepOnA.pushVec3(tempPointA);
-
-    ioManifold.getContactPointB(tempPointB, point1);
-    pointsToKeepOnB.pushVec3(tempPointB);
-
-    if (point3 !== -1) {
-      ioManifold.getContactPointA(tempPointA, point3);
-      pointsToKeepOnA.pushVec3(tempPointA);
-
-      ioManifold.getContactPointB(tempPointB, point3);
-      pointsToKeepOnB.pushVec3(tempPointB);
-    }
-
-    ioManifold.getContactPointA(tempPointA, point2);
-    pointsToKeepOnA.pushVec3(tempPointA);
-
-    ioManifold.getContactPointB(tempPointB, point2);
-    pointsToKeepOnB.pushVec3(tempPointB);
-
-    if (point4 !== -1) {
-      ioManifold.getContactPointA(tempPointA, point4);
-      pointsToKeepOnA.pushVec3(tempPointA);
-
-      ioManifold.getContactPointB(tempPointB, point4);
-      pointsToKeepOnB.pushVec3(tempPointB);
-    }
-
-    // set the points on the manifold
-    ioManifold.clear();
-
-    for (let i = 0; i < pointsToKeepOnA.numItems; i++) {
-      pointsToKeepOnA.getVec3(tempPointA, i);
-      pointsToKeepOnB.getVec3(tempPointB, i);
-      ioManifold.pushContactPoints(tempPointA, tempPointB);
-    }
-  }
-
-  getContactsFromCache(
-    bodyA: Body,
-    bodyB: Body,
-    contactConstraintModule: ContactConstraintModule,
-    sleepModule: SleepModule,
-    isWarmStartingEnabled: boolean,
-    timeStepSizeSeconds: number,
-    minVelocityForElasticContact: number
-  ): [boolean, boolean] {
-    let pairHandled = false;
-    let constraintCreated = false;
-
-    // find the previous cached pair
-    const pairKey = createContactPairKey(bodyA, bodyB);
-    const previousPair = this.previousManifoldCache.pairMap.get(pairKey);
-
-    // exit if previous cached pair doesn't exist
-    if (previousPair === undefined) {
-      return [pairHandled, constraintCreated];
-    }
-
-    // get the current relative translation (AB) in A space
-
-    inverseOrientationA.conjugateQuat(bodyA.orientation); // we're able to conjugate instead of invert because it's a unit quaternion
-
-    translationAB.subtractVectors(bodyB.computedCenterOfMassPosition, bodyA.computedCenterOfMassPosition);
-
-    translationAB.transformVectorByQuat(translationAB, inverseOrientationA);
-
-    // compare with the previous relative translation (AB) in A space
-    const squaredDistance = translationAB.squaredDistance(previousPair.translationAB);
-
-    // exit if the relative translation has changed too much
-    if (squaredDistance > contactPairCacheMaxDeltaPositionSquared) {
-      return [pairHandled, constraintCreated];
-    }
-
-    // get the current relative orientation (AB) in A space
-
-    rotationAB.multiplyQuats(inverseOrientationA, bodyB.orientation);
-
-    // compare with the previous relative orientation (AB) in A space
-    const deltaAngle = Math.abs(rotationAB.dot(previousPair.rotationAB));
-
-    // exit if the relative orientation has changed too much
-    if (deltaAngle < contactPairCacheCosMaxDeltaRotationDiv2) {
-      return [pairHandled, constraintCreated];
-    }
-
-    // if we've reached here, the previous cache is valid
-    pairHandled = true;
-
-    // 1. create a new pair in the current cache and copy the previous cached pair data
-
-    const currentPair = ContactPair.create(
-      {
-        bodyA: bodyA,
-        bodyB: bodyB,
-        firstContactManifold: null, // will be set later
-        translationAB: translationAB,
-        rotationAB: rotationAB,
-      },
-      this.currentManifoldCache.pairs
-    ) as ContactPair;
-
-    // copy the previous cached pair data
-    currentPair.copy(previousPair);
-
-    // add the pair to the pair map AFTER copying the data
-    this.currentManifoldCache.pairMap.set(currentPair.key, currentPair);
-
-    // exit if no contact manifolds to handle
-    if (!currentPair.firstContactManifold) {
-      return [pairHandled, constraintCreated];
-    }
-
-    // 2. create new manifolds and copy manifold data. care must be taken here as the manifold ids are different between the two caches!!
-
-    // reset the current contact pair's first manifold id
-    // TODO: replace or implement the manifold linked list
-    currentPair.firstContactManifold = null;
-
-    // get local to world transforms for each body
-
-    localToWorldA.fromRotationTranslation(bodyA.orientation, bodyA.computedCenterOfMassPosition);
-    localToWorldB.fromRotationTranslation(bodyB.orientation, bodyB.computedCenterOfMassPosition);
-
-    // walk over all manifolds in the previous cache and for each one, create a new manifold in the current cache with the same data (ids will be different)
-    // TODO: replace or implement the manifold linked list
-    let nextManifoldIdInPreviousCache = previousPair.firstContactManifold;
-    while (nextManifoldIdInPreviousCache !== null) {
-      // add a new contact manifold and manifold constraint
-      // convert the previous manifold from local space into a temp manifold in world space
-      // memcopy the previous manifold into the temp manifold
-      tempManifold.copy(nextManifoldIdInPreviousCache);
-      tempManifold.nextContactManifold = null;
-
-      // convert the normal from B space to world space
-      localToWorldB.multiply3x3(tempManifold.worldSpaceNormal, nextManifoldIdInPreviousCache.worldSpaceNormal);
-      tempManifold.worldSpaceNormal.normalize();
-
-      // estimate a new penetration depth
-      let penetrationDepth = -Infinity;
-
-      for (let i = 0; i < nextManifoldIdInPreviousCache.numContacts; i++) {
-        // get the contact point in local space
-        nextManifoldIdInPreviousCache.getContactPointA(localPointA, i);
-        nextManifoldIdInPreviousCache.getContactPointB(localPointB, i);
-
-        // convert the contact point to world space
-        worldPointA.transformVectorFromMat4(localPointA, localToWorldA);
-        worldPointB.transformVectorFromMat4(localPointB, localToWorldB);
-
-        // set the contact points in the temp manifold
-        tempManifold.setContactPointA(worldPointA, i);
-        tempManifold.setContactPointB(worldPointB, i);
-
-        // calculate the penetration depth
-        vectorBA.subtractVectors(worldPointA, worldPointB);
-        penetrationDepth = Math.max(penetrationDepth, vectorBA.dot(tempManifold.worldSpaceNormal));
-
-        // copy the lambdas
-        if (isWarmStartingEnabled) {
-          tempManifold.copyLambda(nextManifoldIdInPreviousCache, i);
-        }
-      }
-
-      tempManifold.penetrationDepth = penetrationDepth;
-
-      contactConstraintModule.addContactConstraints(
-        bodyA,
-        bodyB,
-        tempManifold,
-        timeStepSizeSeconds,
-        isWarmStartingEnabled,
-        minVelocityForElasticContact
-      );
-      constraintCreated = true;
-
-      // get the next manifold id in the previous cache
-      // TODO: replace or implement the manifold linked list
-      nextManifoldIdInPreviousCache = nextManifoldIdInPreviousCache.nextContactManifold;
-    }
-
-    return [pairHandled, constraintCreated];
-  }
-
-  manifoldBetweenTwoFaces(
-    pointA: Vec3,
-    pointB: Vec3,
-    penetrationAxis: Vec3,
-    maxContactDistanceSquared: number,
-    faceA: Face,
-    faceB: Face,
-    outManifold: ContactManifold
-  ): void {
-    // remember size before adding new points, to check if we added any
-    let originalNumberOfContactPoints = outManifold.numContacts;
-
-    // case: both faces are polygons
-    if (faceA.numVertices >= 2 && faceB.numVertices >= 3) {
-      // clip polygon of face B against face A
-      clippedFace.clear();
-
-      // case: face A is a polygon
-      if (faceA.numVertices >= 3) {
-        clipPolyVsPoly(clippedFace, faceB, faceA, penetrationAxis);
-      }
-      // case: face A is an edge
-      else if (faceA.numVertices === 2) {
-        faceA.getVertex(edgeVertex1, 0);
-
-        faceA.getVertex(edgeVertex2, 1);
-
-        clipPolyVsEdge(clippedFace, faceB, edgeVertex1, edgeVertex2, penetrationAxis);
-      }
-
-      // project the points back onto the plane of face A and only keep those that are behind the plane
-
-      planeOrigin.zero();
-
-      planeNormal.zero();
-
-      firstEdge.zero();
-
-      secondEdge.zero();
-
-      // get first vertex
-      faceA.getVertex(planeOrigin, 0);
-
-      // get first edge
-      faceA.getVertex(firstEdge, 1);
-      firstEdge.subtractVectors(firstEdge, planeOrigin);
-
-      // if (faceA.vertexCapacity >= 3) {
-      if (faceA.numVertices >= 3) {
-        // get second edge
-        faceA.getVertex(secondEdge, 2);
-        secondEdge.subtractVectors(secondEdge, planeOrigin);
-
-        // three vertices, so we can calculate the normal
-        planeNormal.crossVectors(firstEdge, secondEdge);
-      } else {
-        // two vertices, first find a perpendicular to the first edge and penetration axis and then use the perpendicular with the edge to get the normal
-
-        perpendicular.crossVectors(firstEdge, penetrationAxis);
-        planeNormal.crossVectors(perpendicular, firstEdge);
-      }
-
-      negatedPenetrationAxis.negateVector(penetrationAxis);
-      // check if the plane normal has any length, if not the clipped shape is so small that we'll just use the contact points
-      const penetrationAxisDotPlaneNormal = penetrationAxis.dot(planeNormal);
-      if (penetrationAxisDotPlaneNormal != 0.0) {
-        const penetrationAxisLength = penetrationAxis.length();
-
-        // discard the points of faces that are too far away to collide
-        // iterate over clipped face vertices
-        for (let i = 0; i < clippedFace.numVertices; i++) {
-          clippedFace.getVertex(p2, i);
-          vectorAB.subtractVectors(p2, planeOrigin);
-          const distance = vectorAB.dot(planeNormal) / penetrationAxisDotPlaneNormal;
-          if (distance * penetrationAxisLength < maxContactDistanceSquared) {
-            p1.addScaledToVector(p2, negatedPenetrationAxis, distance);
-
-            // add the contact points
-            outManifold.pushContactPoints(p1, p2);
-          }
-        }
-      }
-    }
-
-    // case: use contact points themselves if no new points were added
-    if (originalNumberOfContactPoints === outManifold.numContacts) {
-      outManifold.pushContactPoints(pointA, pointB);
-    }
-  }
-
-  flipCache(): void {
-    // switch the current cache with the previous cache
-    this.currentManifoldCacheIndex ^= 1;
-
-    // clear the current cache
-    this.currentManifoldCache.clear();
-  }
-}