@perplexdotgg/bounce 1.0.0

package/src/physics/manifold/ContactManifoldModule.ts

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