@pibbl/core 0.0.1

package/dist/features/physics/lib/2d/world/contact-cache.js

@@ -0,0 +1,497 @@
+const COLLIDER_SENSOR_2D = 1 << 0;
+const CONTACT_EVENT_BEGIN_2D = 1;
+const CONTACT_EVENT_END_2D = 2;
+const OVERLAP_EVENT_BEGIN_2D = 3;
+const OVERLAP_EVENT_END_2D = 4;
+const POINTS_PER_CONTACT = 2;
+class ContactCache2D {
+  contactCount = 0;
+  firstColliderIndices;
+  firstColliderGenerations;
+  secondColliderIndices;
+  secondColliderGenerations;
+  firstBodyIndices;
+  firstBodyGenerations;
+  secondBodyIndices;
+  secondBodyGenerations;
+  sensorFlags;
+  mixedFriction;
+  mixedRestitution;
+  normalX;
+  normalY;
+  firstLeafIndices;
+  secondLeafIndices;
+  pointCounts;
+  pointFirstX;
+  pointFirstY;
+  pointSecondX;
+  pointSecondY;
+  pointSeparations;
+  pointFirstFeatures;
+  pointSecondFeatures;
+  pointNormalImpulses;
+  pointTangentImpulses;
+  stagingFirstColliderIndices;
+  stagingFirstColliderGenerations;
+  stagingSecondColliderIndices;
+  stagingSecondColliderGenerations;
+  stagingFirstBodyIndices;
+  stagingFirstBodyGenerations;
+  stagingSecondBodyIndices;
+  stagingSecondBodyGenerations;
+  stagingSensorFlags;
+  stagingMixedFriction;
+  stagingMixedRestitution;
+  stagingNormalX;
+  stagingNormalY;
+  stagingFirstLeafIndices;
+  stagingSecondLeafIndices;
+  stagingPointCounts;
+  stagingPointFirstX;
+  stagingPointFirstY;
+  stagingPointSecondX;
+  stagingPointSecondY;
+  stagingPointSeparations;
+  stagingPointFirstFeatures;
+  stagingPointSecondFeatures;
+  stagingPointNormalImpulses;
+  stagingPointTangentImpulses;
+  eventCount = 0;
+  eventTypes;
+  eventFirstColliderIndices;
+  eventFirstColliderGenerations;
+  eventSecondColliderIndices;
+  eventSecondColliderGenerations;
+  constructor(initialCapacity = 4) {
+    const capacity = normalizedCapacity(initialCapacity);
+    this.firstColliderIndices = new Int32Array(capacity);
+    this.firstColliderGenerations = new Uint32Array(capacity);
+    this.secondColliderIndices = new Int32Array(capacity);
+    this.secondColliderGenerations = new Uint32Array(capacity);
+    this.firstBodyIndices = new Int32Array(capacity);
+    this.firstBodyGenerations = new Uint32Array(capacity);
+    this.secondBodyIndices = new Int32Array(capacity);
+    this.secondBodyGenerations = new Uint32Array(capacity);
+    this.sensorFlags = new Uint8Array(capacity);
+    this.mixedFriction = new Float64Array(capacity);
+    this.mixedRestitution = new Float64Array(capacity);
+    this.normalX = new Float64Array(capacity);
+    this.normalY = new Float64Array(capacity);
+    this.firstLeafIndices = new Int32Array(capacity);
+    this.secondLeafIndices = new Int32Array(capacity);
+    this.pointCounts = new Uint8Array(capacity);
+    this.pointFirstX = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.pointFirstY = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.pointSecondX = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.pointSecondY = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.pointSeparations = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.pointFirstFeatures = new Int32Array(capacity * POINTS_PER_CONTACT);
+    this.pointSecondFeatures = new Int32Array(capacity * POINTS_PER_CONTACT);
+    this.pointNormalImpulses = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.pointTangentImpulses = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.stagingFirstColliderIndices = new Int32Array(capacity);
+    this.stagingFirstColliderGenerations = new Uint32Array(capacity);
+    this.stagingSecondColliderIndices = new Int32Array(capacity);
+    this.stagingSecondColliderGenerations = new Uint32Array(capacity);
+    this.stagingFirstBodyIndices = new Int32Array(capacity);
+    this.stagingFirstBodyGenerations = new Uint32Array(capacity);
+    this.stagingSecondBodyIndices = new Int32Array(capacity);
+    this.stagingSecondBodyGenerations = new Uint32Array(capacity);
+    this.stagingSensorFlags = new Uint8Array(capacity);
+    this.stagingMixedFriction = new Float64Array(capacity);
+    this.stagingMixedRestitution = new Float64Array(capacity);
+    this.stagingNormalX = new Float64Array(capacity);
+    this.stagingNormalY = new Float64Array(capacity);
+    this.stagingFirstLeafIndices = new Int32Array(capacity);
+    this.stagingSecondLeafIndices = new Int32Array(capacity);
+    this.stagingPointCounts = new Uint8Array(capacity);
+    this.stagingPointFirstX = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.stagingPointFirstY = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.stagingPointSecondX = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.stagingPointSecondY = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.stagingPointSeparations = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.stagingPointFirstFeatures = new Int32Array(capacity * POINTS_PER_CONTACT);
+    this.stagingPointSecondFeatures = new Int32Array(capacity * POINTS_PER_CONTACT);
+    this.stagingPointNormalImpulses = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.stagingPointTangentImpulses = new Float64Array(capacity * POINTS_PER_CONTACT);
+    this.eventTypes = new Uint8Array(capacity * 2);
+    this.eventFirstColliderIndices = new Int32Array(capacity * 2);
+    this.eventFirstColliderGenerations = new Uint32Array(capacity * 2);
+    this.eventSecondColliderIndices = new Int32Array(capacity * 2);
+    this.eventSecondColliderGenerations = new Uint32Array(capacity * 2);
+  }
+  ensureCapacity(required) {
+    if (required <= this.firstColliderIndices.length) return;
+    let capacity = this.firstColliderIndices.length;
+    while (capacity < required) capacity *= 2;
+    this.firstColliderIndices = growInt32(this.firstColliderIndices, capacity);
+    this.firstColliderGenerations = growUint32(this.firstColliderGenerations, capacity);
+    this.secondColliderIndices = growInt32(this.secondColliderIndices, capacity);
+    this.secondColliderGenerations = growUint32(this.secondColliderGenerations, capacity);
+    this.firstBodyIndices = growInt32(this.firstBodyIndices, capacity);
+    this.firstBodyGenerations = growUint32(this.firstBodyGenerations, capacity);
+    this.secondBodyIndices = growInt32(this.secondBodyIndices, capacity);
+    this.secondBodyGenerations = growUint32(this.secondBodyGenerations, capacity);
+    this.sensorFlags = growUint8(this.sensorFlags, capacity);
+    this.mixedFriction = growFloat64(this.mixedFriction, capacity);
+    this.mixedRestitution = growFloat64(this.mixedRestitution, capacity);
+    this.normalX = growFloat64(this.normalX, capacity);
+    this.normalY = growFloat64(this.normalY, capacity);
+    this.firstLeafIndices = growInt32(this.firstLeafIndices, capacity);
+    this.secondLeafIndices = growInt32(this.secondLeafIndices, capacity);
+    this.pointCounts = growUint8(this.pointCounts, capacity);
+    this.pointFirstX = growFloat64(this.pointFirstX, capacity * POINTS_PER_CONTACT);
+    this.pointFirstY = growFloat64(this.pointFirstY, capacity * POINTS_PER_CONTACT);
+    this.pointSecondX = growFloat64(this.pointSecondX, capacity * POINTS_PER_CONTACT);
+    this.pointSecondY = growFloat64(this.pointSecondY, capacity * POINTS_PER_CONTACT);
+    this.pointSeparations = growFloat64(this.pointSeparations, capacity * POINTS_PER_CONTACT);
+    this.pointFirstFeatures = growInt32(this.pointFirstFeatures, capacity * POINTS_PER_CONTACT);
+    this.pointSecondFeatures = growInt32(this.pointSecondFeatures, capacity * POINTS_PER_CONTACT);
+    this.pointNormalImpulses = growFloat64(this.pointNormalImpulses, capacity * POINTS_PER_CONTACT);
+    this.pointTangentImpulses = growFloat64(this.pointTangentImpulses, capacity * POINTS_PER_CONTACT);
+    this.stagingFirstColliderIndices = growInt32(this.stagingFirstColliderIndices, capacity);
+    this.stagingFirstColliderGenerations = growUint32(this.stagingFirstColliderGenerations, capacity);
+    this.stagingSecondColliderIndices = growInt32(this.stagingSecondColliderIndices, capacity);
+    this.stagingSecondColliderGenerations = growUint32(this.stagingSecondColliderGenerations, capacity);
+    this.stagingFirstBodyIndices = growInt32(this.stagingFirstBodyIndices, capacity);
+    this.stagingFirstBodyGenerations = growUint32(this.stagingFirstBodyGenerations, capacity);
+    this.stagingSecondBodyIndices = growInt32(this.stagingSecondBodyIndices, capacity);
+    this.stagingSecondBodyGenerations = growUint32(this.stagingSecondBodyGenerations, capacity);
+    this.stagingSensorFlags = growUint8(this.stagingSensorFlags, capacity);
+    this.stagingMixedFriction = growFloat64(this.stagingMixedFriction, capacity);
+    this.stagingMixedRestitution = growFloat64(this.stagingMixedRestitution, capacity);
+    this.stagingNormalX = growFloat64(this.stagingNormalX, capacity);
+    this.stagingNormalY = growFloat64(this.stagingNormalY, capacity);
+    this.stagingFirstLeafIndices = growInt32(this.stagingFirstLeafIndices, capacity);
+    this.stagingSecondLeafIndices = growInt32(this.stagingSecondLeafIndices, capacity);
+    this.stagingPointCounts = growUint8(this.stagingPointCounts, capacity);
+    this.stagingPointFirstX = growFloat64(this.stagingPointFirstX, capacity * POINTS_PER_CONTACT);
+    this.stagingPointFirstY = growFloat64(this.stagingPointFirstY, capacity * POINTS_PER_CONTACT);
+    this.stagingPointSecondX = growFloat64(this.stagingPointSecondX, capacity * POINTS_PER_CONTACT);
+    this.stagingPointSecondY = growFloat64(this.stagingPointSecondY, capacity * POINTS_PER_CONTACT);
+    this.stagingPointSeparations = growFloat64(this.stagingPointSeparations, capacity * POINTS_PER_CONTACT);
+    this.stagingPointFirstFeatures = growInt32(this.stagingPointFirstFeatures, capacity * POINTS_PER_CONTACT);
+    this.stagingPointSecondFeatures = growInt32(this.stagingPointSecondFeatures, capacity * POINTS_PER_CONTACT);
+    this.stagingPointNormalImpulses = growFloat64(this.stagingPointNormalImpulses, capacity * POINTS_PER_CONTACT);
+    this.stagingPointTangentImpulses = growFloat64(this.stagingPointTangentImpulses, capacity * POINTS_PER_CONTACT);
+    this.ensureEventCapacity(capacity * 2);
+  }
+  ensureEventCapacity(required) {
+    if (required <= this.eventTypes.length) return;
+    let capacity = this.eventTypes.length;
+    while (capacity < required) capacity *= 2;
+    this.eventTypes = growUint8(this.eventTypes, capacity);
+    this.eventFirstColliderIndices = growInt32(this.eventFirstColliderIndices, capacity);
+    this.eventFirstColliderGenerations = growUint32(this.eventFirstColliderGenerations, capacity);
+    this.eventSecondColliderIndices = growInt32(this.eventSecondColliderIndices, capacity);
+    this.eventSecondColliderGenerations = growUint32(this.eventSecondColliderGenerations, capacity);
+  }
+  swapGenerations(nextCount, nextEventCount) {
+    let int32 = this.firstColliderIndices;
+    this.firstColliderIndices = this.stagingFirstColliderIndices;
+    this.stagingFirstColliderIndices = int32;
+    let uint32 = this.firstColliderGenerations;
+    this.firstColliderGenerations = this.stagingFirstColliderGenerations;
+    this.stagingFirstColliderGenerations = uint32;
+    int32 = this.secondColliderIndices;
+    this.secondColliderIndices = this.stagingSecondColliderIndices;
+    this.stagingSecondColliderIndices = int32;
+    uint32 = this.secondColliderGenerations;
+    this.secondColliderGenerations = this.stagingSecondColliderGenerations;
+    this.stagingSecondColliderGenerations = uint32;
+    int32 = this.firstBodyIndices;
+    this.firstBodyIndices = this.stagingFirstBodyIndices;
+    this.stagingFirstBodyIndices = int32;
+    uint32 = this.firstBodyGenerations;
+    this.firstBodyGenerations = this.stagingFirstBodyGenerations;
+    this.stagingFirstBodyGenerations = uint32;
+    int32 = this.secondBodyIndices;
+    this.secondBodyIndices = this.stagingSecondBodyIndices;
+    this.stagingSecondBodyIndices = int32;
+    uint32 = this.secondBodyGenerations;
+    this.secondBodyGenerations = this.stagingSecondBodyGenerations;
+    this.stagingSecondBodyGenerations = uint32;
+    let uint8 = this.sensorFlags;
+    this.sensorFlags = this.stagingSensorFlags;
+    this.stagingSensorFlags = uint8;
+    let float64 = this.mixedFriction;
+    this.mixedFriction = this.stagingMixedFriction;
+    this.stagingMixedFriction = float64;
+    float64 = this.mixedRestitution;
+    this.mixedRestitution = this.stagingMixedRestitution;
+    this.stagingMixedRestitution = float64;
+    float64 = this.normalX;
+    this.normalX = this.stagingNormalX;
+    this.stagingNormalX = float64;
+    float64 = this.normalY;
+    this.normalY = this.stagingNormalY;
+    this.stagingNormalY = float64;
+    int32 = this.firstLeafIndices;
+    this.firstLeafIndices = this.stagingFirstLeafIndices;
+    this.stagingFirstLeafIndices = int32;
+    int32 = this.secondLeafIndices;
+    this.secondLeafIndices = this.stagingSecondLeafIndices;
+    this.stagingSecondLeafIndices = int32;
+    uint8 = this.pointCounts;
+    this.pointCounts = this.stagingPointCounts;
+    this.stagingPointCounts = uint8;
+    float64 = this.pointFirstX;
+    this.pointFirstX = this.stagingPointFirstX;
+    this.stagingPointFirstX = float64;
+    float64 = this.pointFirstY;
+    this.pointFirstY = this.stagingPointFirstY;
+    this.stagingPointFirstY = float64;
+    float64 = this.pointSecondX;
+    this.pointSecondX = this.stagingPointSecondX;
+    this.stagingPointSecondX = float64;
+    float64 = this.pointSecondY;
+    this.pointSecondY = this.stagingPointSecondY;
+    this.stagingPointSecondY = float64;
+    float64 = this.pointSeparations;
+    this.pointSeparations = this.stagingPointSeparations;
+    this.stagingPointSeparations = float64;
+    int32 = this.pointFirstFeatures;
+    this.pointFirstFeatures = this.stagingPointFirstFeatures;
+    this.stagingPointFirstFeatures = int32;
+    int32 = this.pointSecondFeatures;
+    this.pointSecondFeatures = this.stagingPointSecondFeatures;
+    this.stagingPointSecondFeatures = int32;
+    float64 = this.pointNormalImpulses;
+    this.pointNormalImpulses = this.stagingPointNormalImpulses;
+    this.stagingPointNormalImpulses = float64;
+    float64 = this.pointTangentImpulses;
+    this.pointTangentImpulses = this.stagingPointTangentImpulses;
+    this.stagingPointTangentImpulses = float64;
+    this.contactCount = nextCount;
+    this.eventCount = nextEventCount;
+  }
+  writeStagingContact(target, firstColliderIndex, firstColliderGeneration, secondColliderIndex, secondColliderGeneration, colliders, manifold, oldContact) {
+    this.stagingFirstColliderIndices[target] = firstColliderIndex;
+    this.stagingFirstColliderGenerations[target] = firstColliderGeneration;
+    this.stagingSecondColliderIndices[target] = secondColliderIndex;
+    this.stagingSecondColliderGenerations[target] = secondColliderGeneration;
+    this.stagingFirstBodyIndices[target] = colliders.bodyIndices[firstColliderIndex];
+    this.stagingFirstBodyGenerations[target] = colliders.bodyGenerations[firstColliderIndex];
+    this.stagingSecondBodyIndices[target] = colliders.bodyIndices[secondColliderIndex];
+    this.stagingSecondBodyGenerations[target] = colliders.bodyGenerations[secondColliderIndex];
+    const sensor = ((colliders.flags[firstColliderIndex] | colliders.flags[secondColliderIndex]) & COLLIDER_SENSOR_2D) !== 0;
+    this.stagingSensorFlags[target] = sensor ? 1 : 0;
+    const firstFriction = materialNumberAt(
+      colliders,
+      firstColliderIndex,
+      "friction",
+      0.5
+    );
+    const secondFriction = materialNumberAt(
+      colliders,
+      secondColliderIndex,
+      "friction",
+      0.5
+    );
+    this.stagingMixedFriction[target] = Math.sqrt(
+      firstFriction * secondFriction
+    );
+    this.stagingMixedRestitution[target] = Math.max(
+      materialNumberAt(colliders, firstColliderIndex, "restitution", 0),
+      materialNumberAt(colliders, secondColliderIndex, "restitution", 0)
+    );
+    this.stagingNormalX[target] = manifold.normalX;
+    this.stagingNormalY[target] = manifold.normalY;
+    this.stagingFirstLeafIndices[target] = manifold.firstLeaf;
+    this.stagingSecondLeafIndices[target] = manifold.secondLeaf;
+    const pointCount = Math.min(POINTS_PER_CONTACT, manifold.points.length);
+    this.stagingPointCounts[target] = pointCount;
+    let firstPoint = 0;
+    let secondPoint = 1;
+    if (pointCount === 2 && compareManifoldPoints(manifold.points[0], manifold.points[1]) > 0) {
+      firstPoint = 1;
+      secondPoint = 0;
+    }
+    for (let pointIndex = 0; pointIndex < POINTS_PER_CONTACT; pointIndex += 1) {
+      const targetPoint = target * POINTS_PER_CONTACT + pointIndex;
+      if (pointIndex >= pointCount) {
+        clearStagingPoint(this, targetPoint);
+        continue;
+      }
+      const sourcePoint = manifold.points[pointIndex === 0 ? firstPoint : secondPoint];
+      this.stagingPointFirstX[targetPoint] = sourcePoint.firstX;
+      this.stagingPointFirstY[targetPoint] = sourcePoint.firstY;
+      this.stagingPointSecondX[targetPoint] = sourcePoint.secondX;
+      this.stagingPointSecondY[targetPoint] = sourcePoint.secondY;
+      this.stagingPointSeparations[targetPoint] = sourcePoint.separation;
+      this.stagingPointFirstFeatures[targetPoint] = sourcePoint.firstFeature;
+      this.stagingPointSecondFeatures[targetPoint] = sourcePoint.secondFeature;
+      const oldPoint = oldContact < 0 ? -1 : this.findMatchingPoint(oldContact, manifold.firstLeaf, manifold.secondLeaf, sourcePoint.firstFeature, sourcePoint.secondFeature);
+      this.stagingPointNormalImpulses[targetPoint] = oldPoint < 0 ? 0 : this.pointNormalImpulses[oldPoint];
+      this.stagingPointTangentImpulses[targetPoint] = oldPoint < 0 ? 0 : this.pointTangentImpulses[oldPoint];
+    }
+  }
+  findMatchingPoint(oldContact, firstLeaf, secondLeaf, firstFeature, secondFeature) {
+    if (this.firstLeafIndices[oldContact] !== firstLeaf || this.secondLeafIndices[oldContact] !== secondLeaf) return -1;
+    const base = oldContact * POINTS_PER_CONTACT;
+    for (let point = 0; point < this.pointCounts[oldContact]; point += 1) {
+      const index = base + point;
+      if (this.pointFirstFeatures[index] === firstFeature && this.pointSecondFeatures[index] === secondFeature) return index;
+    }
+    return -1;
+  }
+}
+function updateSortedContactCache2D(cache, pairs, colliders, manifoldProvider) {
+  cache.ensureCapacity(cache.contactCount + pairs.pairCount);
+  cache.ensureEventCapacity(cache.contactCount + pairs.pairCount);
+  let oldContact = 0;
+  let pair = 0;
+  let nextContact = 0;
+  let nextEvent = 0;
+  while (oldContact < cache.contactCount || pair < pairs.pairCount) {
+    let firstIndex;
+    let firstGeneration;
+    let secondIndex;
+    let secondGeneration;
+    let matchesOld = false;
+    if (oldContact >= cache.contactCount) {
+      firstIndex = pairs.pairFirstColliderIndices[pair];
+      firstGeneration = pairs.pairFirstColliderGenerations[pair];
+      secondIndex = pairs.pairSecondColliderIndices[pair];
+      secondGeneration = pairs.pairSecondColliderGenerations[pair];
+      pair += 1;
+    } else if (pair >= pairs.pairCount) {
+      firstIndex = cache.firstColliderIndices[oldContact];
+      firstGeneration = cache.firstColliderGenerations[oldContact];
+      secondIndex = cache.secondColliderIndices[oldContact];
+      secondGeneration = cache.secondColliderGenerations[oldContact];
+      matchesOld = true;
+      oldContact += 1;
+    } else {
+      const comparison = compareContactToPair(
+        cache,
+        oldContact,
+        pairs.pairFirstColliderIndices[pair],
+        pairs.pairFirstColliderGenerations[pair],
+        pairs.pairSecondColliderIndices[pair],
+        pairs.pairSecondColliderGenerations[pair]
+      );
+      if (comparison <= 0) {
+        firstIndex = cache.firstColliderIndices[oldContact];
+        firstGeneration = cache.firstColliderGenerations[oldContact];
+        secondIndex = cache.secondColliderIndices[oldContact];
+        secondGeneration = cache.secondColliderGenerations[oldContact];
+        matchesOld = true;
+        oldContact += 1;
+        if (comparison === 0) pair += 1;
+      } else {
+        firstIndex = pairs.pairFirstColliderIndices[pair];
+        firstGeneration = pairs.pairFirstColliderGenerations[pair];
+        secondIndex = pairs.pairSecondColliderIndices[pair];
+        secondGeneration = pairs.pairSecondColliderGenerations[pair];
+        pair += 1;
+      }
+    }
+    const collidersLive = colliders.has(firstIndex, firstGeneration) && colliders.has(secondIndex, secondGeneration);
+    const sameBody = collidersLive && colliders.bodyIndices[firstIndex] === colliders.bodyIndices[secondIndex] && colliders.bodyGenerations[firstIndex] === colliders.bodyGenerations[secondIndex];
+    const manifold = collidersLive && !sameBody ? manifoldProvider(firstIndex, secondIndex) : null;
+    if (manifold !== null && manifold.points.length > 0) {
+      const oldIndex = matchesOld ? oldContact - 1 : -1;
+      const sensor = ((colliders.flags[firstIndex] | colliders.flags[secondIndex]) & COLLIDER_SENSOR_2D) !== 0;
+      const changesSensorState = oldIndex >= 0 && cache.sensorFlags[oldIndex] !== 0 !== sensor;
+      cache.writeStagingContact(
+        nextContact,
+        firstIndex,
+        firstGeneration,
+        secondIndex,
+        secondGeneration,
+        colliders,
+        manifold,
+        changesSensorState ? -1 : oldIndex
+      );
+      if (changesSensorState) {
+        nextEvent = writeEndEvent(cache, nextEvent, oldIndex);
+        nextEvent = writeBeginEvent(cache, nextEvent, nextContact);
+      } else if (!matchesOld) {
+        nextEvent = writeBeginEvent(cache, nextEvent, nextContact);
+      }
+      nextContact += 1;
+    } else if (matchesOld) {
+      nextEvent = writeEndEvent(cache, nextEvent, oldContact - 1);
+    }
+  }
+  cache.swapGenerations(nextContact, nextEvent);
+}
+function compareContactToPair(cache, contact, firstIndex, firstGeneration, secondIndex, secondGeneration) {
+  return compareIdentity(cache.firstColliderIndices[contact], cache.firstColliderGenerations[contact], firstIndex, firstGeneration) || compareIdentity(cache.secondColliderIndices[contact], cache.secondColliderGenerations[contact], secondIndex, secondGeneration);
+}
+function compareIdentity(firstIndex, firstGeneration, secondIndex, secondGeneration) {
+  return firstIndex - secondIndex || firstGeneration - secondGeneration;
+}
+function writeBeginEvent(cache, event, stagingContact) {
+  cache.eventTypes[event] = cache.stagingSensorFlags[stagingContact] !== 0 ? OVERLAP_EVENT_BEGIN_2D : CONTACT_EVENT_BEGIN_2D;
+  cache.eventFirstColliderIndices[event] = cache.stagingFirstColliderIndices[stagingContact];
+  cache.eventFirstColliderGenerations[event] = cache.stagingFirstColliderGenerations[stagingContact];
+  cache.eventSecondColliderIndices[event] = cache.stagingSecondColliderIndices[stagingContact];
+  cache.eventSecondColliderGenerations[event] = cache.stagingSecondColliderGenerations[stagingContact];
+  return event + 1;
+}
+function writeEndEvent(cache, event, contact) {
+  cache.eventTypes[event] = cache.sensorFlags[contact] !== 0 ? OVERLAP_EVENT_END_2D : CONTACT_EVENT_END_2D;
+  cache.eventFirstColliderIndices[event] = cache.firstColliderIndices[contact];
+  cache.eventFirstColliderGenerations[event] = cache.firstColliderGenerations[contact];
+  cache.eventSecondColliderIndices[event] = cache.secondColliderIndices[contact];
+  cache.eventSecondColliderGenerations[event] = cache.secondColliderGenerations[contact];
+  return event + 1;
+}
+function materialNumberAt(colliders, colliderIndex, property, fallback) {
+  const material = colliders.materials[colliderIndex];
+  return material?.[property] ?? fallback;
+}
+function compareManifoldPoints(first, second) {
+  return first.firstFeature - second.firstFeature || first.secondFeature - second.secondFeature || first.firstX - second.firstX || first.firstY - second.firstY || first.secondX - second.secondX || first.secondY - second.secondY;
+}
+function clearStagingPoint(cache, point) {
+  cache.stagingPointFirstX[point] = 0;
+  cache.stagingPointFirstY[point] = 0;
+  cache.stagingPointSecondX[point] = 0;
+  cache.stagingPointSecondY[point] = 0;
+  cache.stagingPointSeparations[point] = 0;
+  cache.stagingPointFirstFeatures[point] = 0;
+  cache.stagingPointSecondFeatures[point] = 0;
+  cache.stagingPointNormalImpulses[point] = 0;
+  cache.stagingPointTangentImpulses[point] = 0;
+}
+function normalizedCapacity(initialCapacity) {
+  if (!Number.isInteger(initialCapacity) || initialCapacity < 1) {
+    throw new RangeError("initialCapacity must be a positive integer.");
+  }
+  let capacity = 1;
+  while (capacity < initialCapacity) capacity *= 2;
+  return capacity;
+}
+function growInt32(source, capacity) {
+  const result = new Int32Array(capacity);
+  result.set(source);
+  return result;
+}
+function growUint32(source, capacity) {
+  const result = new Uint32Array(capacity);
+  result.set(source);
+  return result;
+}
+function growUint8(source, capacity) {
+  const result = new Uint8Array(capacity);
+  result.set(source);
+  return result;
+}
+function growFloat64(source, capacity) {
+  const result = new Float64Array(capacity);
+  result.set(source);
+  return result;
+}
+export {
+  COLLIDER_SENSOR_2D,
+  CONTACT_EVENT_BEGIN_2D,
+  CONTACT_EVENT_END_2D,
+  ContactCache2D,
+  OVERLAP_EVENT_BEGIN_2D,
+  OVERLAP_EVENT_END_2D,
+  updateSortedContactCache2D
+};
+//# sourceMappingURL=contact-cache.js.map

package/dist/features/physics/lib/2d/world/contact-cache.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/world/contact-cache.ts"],
+  "sourcesContent": ["import type { PrivateManifold2D } from \"../collision/manifold.js\";\nimport type { ColliderStore2D } from \"./storage.js\";\n\nexport const COLLIDER_SENSOR_2D = 1 << 0;\n\nexport const CONTACT_EVENT_BEGIN_2D = 1;\nexport const CONTACT_EVENT_END_2D = 2;\nexport const OVERLAP_EVENT_BEGIN_2D = 3;\nexport const OVERLAP_EVENT_END_2D = 4;\n\nconst POINTS_PER_CONTACT = 2;\n\nexport interface SortedColliderPairs2D {\n  readonly pairFirstColliderIndices: Int32Array;\n  readonly pairFirstColliderGenerations: Uint32Array;\n  readonly pairSecondColliderIndices: Int32Array;\n  readonly pairSecondColliderGenerations: Uint32Array;\n  readonly pairCount: number;\n}\n\nexport type PrivateManifoldProvider2D = (\n  firstColliderIndex: number,\n  secondColliderIndex: number,\n) => PrivateManifold2D | null;\n\nexport class ContactCache2D {\n  contactCount = 0;\n  firstColliderIndices: Int32Array;\n  firstColliderGenerations: Uint32Array;\n  secondColliderIndices: Int32Array;\n  secondColliderGenerations: Uint32Array;\n  firstBodyIndices: Int32Array;\n  firstBodyGenerations: Uint32Array;\n  secondBodyIndices: Int32Array;\n  secondBodyGenerations: Uint32Array;\n  sensorFlags: Uint8Array;\n  mixedFriction: Float64Array;\n  mixedRestitution: Float64Array;\n  normalX: Float64Array;\n  normalY: Float64Array;\n  firstLeafIndices: Int32Array;\n  secondLeafIndices: Int32Array;\n  pointCounts: Uint8Array;\n  pointFirstX: Float64Array;\n  pointFirstY: Float64Array;\n  pointSecondX: Float64Array;\n  pointSecondY: Float64Array;\n  pointSeparations: Float64Array;\n  pointFirstFeatures: Int32Array;\n  pointSecondFeatures: Int32Array;\n  pointNormalImpulses: Float64Array;\n  pointTangentImpulses: Float64Array;\n\n  stagingFirstColliderIndices: Int32Array;\n  stagingFirstColliderGenerations: Uint32Array;\n  stagingSecondColliderIndices: Int32Array;\n  stagingSecondColliderGenerations: Uint32Array;\n  stagingFirstBodyIndices: Int32Array;\n  stagingFirstBodyGenerations: Uint32Array;\n  stagingSecondBodyIndices: Int32Array;\n  stagingSecondBodyGenerations: Uint32Array;\n  stagingSensorFlags: Uint8Array;\n  stagingMixedFriction: Float64Array;\n  stagingMixedRestitution: Float64Array;\n  stagingNormalX: Float64Array;\n  stagingNormalY: Float64Array;\n  stagingFirstLeafIndices: Int32Array;\n  stagingSecondLeafIndices: Int32Array;\n  stagingPointCounts: Uint8Array;\n  stagingPointFirstX: Float64Array;\n  stagingPointFirstY: Float64Array;\n  stagingPointSecondX: Float64Array;\n  stagingPointSecondY: Float64Array;\n  stagingPointSeparations: Float64Array;\n  stagingPointFirstFeatures: Int32Array;\n  stagingPointSecondFeatures: Int32Array;\n  stagingPointNormalImpulses: Float64Array;\n  stagingPointTangentImpulses: Float64Array;\n\n  eventCount = 0;\n  eventTypes: Uint8Array;\n  eventFirstColliderIndices: Int32Array;\n  eventFirstColliderGenerations: Uint32Array;\n  eventSecondColliderIndices: Int32Array;\n  eventSecondColliderGenerations: Uint32Array;\n\n  constructor(initialCapacity = 4) {\n    const capacity = normalizedCapacity(initialCapacity);\n    this.firstColliderIndices = new Int32Array(capacity);\n    this.firstColliderGenerations = new Uint32Array(capacity);\n    this.secondColliderIndices = new Int32Array(capacity);\n    this.secondColliderGenerations = new Uint32Array(capacity);\n    this.firstBodyIndices = new Int32Array(capacity);\n    this.firstBodyGenerations = new Uint32Array(capacity);\n    this.secondBodyIndices = new Int32Array(capacity);\n    this.secondBodyGenerations = new Uint32Array(capacity);\n    this.sensorFlags = new Uint8Array(capacity);\n    this.mixedFriction = new Float64Array(capacity);\n    this.mixedRestitution = new Float64Array(capacity);\n    this.normalX = new Float64Array(capacity);\n    this.normalY = new Float64Array(capacity);\n    this.firstLeafIndices = new Int32Array(capacity);\n    this.secondLeafIndices = new Int32Array(capacity);\n    this.pointCounts = new Uint8Array(capacity);\n    this.pointFirstX = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.pointFirstY = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.pointSecondX = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.pointSecondY = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.pointSeparations = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.pointFirstFeatures = new Int32Array(capacity * POINTS_PER_CONTACT);\n    this.pointSecondFeatures = new Int32Array(capacity * POINTS_PER_CONTACT);\n    this.pointNormalImpulses = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.pointTangentImpulses = new Float64Array(capacity * POINTS_PER_CONTACT);\n\n    this.stagingFirstColliderIndices = new Int32Array(capacity);\n    this.stagingFirstColliderGenerations = new Uint32Array(capacity);\n    this.stagingSecondColliderIndices = new Int32Array(capacity);\n    this.stagingSecondColliderGenerations = new Uint32Array(capacity);\n    this.stagingFirstBodyIndices = new Int32Array(capacity);\n    this.stagingFirstBodyGenerations = new Uint32Array(capacity);\n    this.stagingSecondBodyIndices = new Int32Array(capacity);\n    this.stagingSecondBodyGenerations = new Uint32Array(capacity);\n    this.stagingSensorFlags = new Uint8Array(capacity);\n    this.stagingMixedFriction = new Float64Array(capacity);\n    this.stagingMixedRestitution = new Float64Array(capacity);\n    this.stagingNormalX = new Float64Array(capacity);\n    this.stagingNormalY = new Float64Array(capacity);\n    this.stagingFirstLeafIndices = new Int32Array(capacity);\n    this.stagingSecondLeafIndices = new Int32Array(capacity);\n    this.stagingPointCounts = new Uint8Array(capacity);\n    this.stagingPointFirstX = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.stagingPointFirstY = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.stagingPointSecondX = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.stagingPointSecondY = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.stagingPointSeparations = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.stagingPointFirstFeatures = new Int32Array(capacity * POINTS_PER_CONTACT);\n    this.stagingPointSecondFeatures = new Int32Array(capacity * POINTS_PER_CONTACT);\n    this.stagingPointNormalImpulses = new Float64Array(capacity * POINTS_PER_CONTACT);\n    this.stagingPointTangentImpulses = new Float64Array(capacity * POINTS_PER_CONTACT);\n\n    this.eventTypes = new Uint8Array(capacity * 2);\n    this.eventFirstColliderIndices = new Int32Array(capacity * 2);\n    this.eventFirstColliderGenerations = new Uint32Array(capacity * 2);\n    this.eventSecondColliderIndices = new Int32Array(capacity * 2);\n    this.eventSecondColliderGenerations = new Uint32Array(capacity * 2);\n  }\n\n  ensureCapacity(required: number): void {\n    if (required <= this.firstColliderIndices.length) return;\n    let capacity = this.firstColliderIndices.length;\n    while (capacity < required) capacity *= 2;\n    this.firstColliderIndices = growInt32(this.firstColliderIndices, capacity);\n    this.firstColliderGenerations = growUint32(this.firstColliderGenerations, capacity);\n    this.secondColliderIndices = growInt32(this.secondColliderIndices, capacity);\n    this.secondColliderGenerations = growUint32(this.secondColliderGenerations, capacity);\n    this.firstBodyIndices = growInt32(this.firstBodyIndices, capacity);\n    this.firstBodyGenerations = growUint32(this.firstBodyGenerations, capacity);\n    this.secondBodyIndices = growInt32(this.secondBodyIndices, capacity);\n    this.secondBodyGenerations = growUint32(this.secondBodyGenerations, capacity);\n    this.sensorFlags = growUint8(this.sensorFlags, capacity);\n    this.mixedFriction = growFloat64(this.mixedFriction, capacity);\n    this.mixedRestitution = growFloat64(this.mixedRestitution, capacity);\n    this.normalX = growFloat64(this.normalX, capacity);\n    this.normalY = growFloat64(this.normalY, capacity);\n    this.firstLeafIndices = growInt32(this.firstLeafIndices, capacity);\n    this.secondLeafIndices = growInt32(this.secondLeafIndices, capacity);\n    this.pointCounts = growUint8(this.pointCounts, capacity);\n    this.pointFirstX = growFloat64(this.pointFirstX, capacity * POINTS_PER_CONTACT);\n    this.pointFirstY = growFloat64(this.pointFirstY, capacity * POINTS_PER_CONTACT);\n    this.pointSecondX = growFloat64(this.pointSecondX, capacity * POINTS_PER_CONTACT);\n    this.pointSecondY = growFloat64(this.pointSecondY, capacity * POINTS_PER_CONTACT);\n    this.pointSeparations = growFloat64(this.pointSeparations, capacity * POINTS_PER_CONTACT);\n    this.pointFirstFeatures = growInt32(this.pointFirstFeatures, capacity * POINTS_PER_CONTACT);\n    this.pointSecondFeatures = growInt32(this.pointSecondFeatures, capacity * POINTS_PER_CONTACT);\n    this.pointNormalImpulses = growFloat64(this.pointNormalImpulses, capacity * POINTS_PER_CONTACT);\n    this.pointTangentImpulses = growFloat64(this.pointTangentImpulses, capacity * POINTS_PER_CONTACT);\n\n    this.stagingFirstColliderIndices = growInt32(this.stagingFirstColliderIndices, capacity);\n    this.stagingFirstColliderGenerations = growUint32(this.stagingFirstColliderGenerations, capacity);\n    this.stagingSecondColliderIndices = growInt32(this.stagingSecondColliderIndices, capacity);\n    this.stagingSecondColliderGenerations = growUint32(this.stagingSecondColliderGenerations, capacity);\n    this.stagingFirstBodyIndices = growInt32(this.stagingFirstBodyIndices, capacity);\n    this.stagingFirstBodyGenerations = growUint32(this.stagingFirstBodyGenerations, capacity);\n    this.stagingSecondBodyIndices = growInt32(this.stagingSecondBodyIndices, capacity);\n    this.stagingSecondBodyGenerations = growUint32(this.stagingSecondBodyGenerations, capacity);\n    this.stagingSensorFlags = growUint8(this.stagingSensorFlags, capacity);\n    this.stagingMixedFriction = growFloat64(this.stagingMixedFriction, capacity);\n    this.stagingMixedRestitution = growFloat64(this.stagingMixedRestitution, capacity);\n    this.stagingNormalX = growFloat64(this.stagingNormalX, capacity);\n    this.stagingNormalY = growFloat64(this.stagingNormalY, capacity);\n    this.stagingFirstLeafIndices = growInt32(this.stagingFirstLeafIndices, capacity);\n    this.stagingSecondLeafIndices = growInt32(this.stagingSecondLeafIndices, capacity);\n    this.stagingPointCounts = growUint8(this.stagingPointCounts, capacity);\n    this.stagingPointFirstX = growFloat64(this.stagingPointFirstX, capacity * POINTS_PER_CONTACT);\n    this.stagingPointFirstY = growFloat64(this.stagingPointFirstY, capacity * POINTS_PER_CONTACT);\n    this.stagingPointSecondX = growFloat64(this.stagingPointSecondX, capacity * POINTS_PER_CONTACT);\n    this.stagingPointSecondY = growFloat64(this.stagingPointSecondY, capacity * POINTS_PER_CONTACT);\n    this.stagingPointSeparations = growFloat64(this.stagingPointSeparations, capacity * POINTS_PER_CONTACT);\n    this.stagingPointFirstFeatures = growInt32(this.stagingPointFirstFeatures, capacity * POINTS_PER_CONTACT);\n    this.stagingPointSecondFeatures = growInt32(this.stagingPointSecondFeatures, capacity * POINTS_PER_CONTACT);\n    this.stagingPointNormalImpulses = growFloat64(this.stagingPointNormalImpulses, capacity * POINTS_PER_CONTACT);\n    this.stagingPointTangentImpulses = growFloat64(this.stagingPointTangentImpulses, capacity * POINTS_PER_CONTACT);\n    this.ensureEventCapacity(capacity * 2);\n  }\n\n  ensureEventCapacity(required: number): void {\n    if (required <= this.eventTypes.length) return;\n    let capacity = this.eventTypes.length;\n    while (capacity < required) capacity *= 2;\n    this.eventTypes = growUint8(this.eventTypes, capacity);\n    this.eventFirstColliderIndices = growInt32(this.eventFirstColliderIndices, capacity);\n    this.eventFirstColliderGenerations = growUint32(this.eventFirstColliderGenerations, capacity);\n    this.eventSecondColliderIndices = growInt32(this.eventSecondColliderIndices, capacity);\n    this.eventSecondColliderGenerations = growUint32(this.eventSecondColliderGenerations, capacity);\n  }\n\n  swapGenerations(nextCount: number, nextEventCount: number): void {\n    let int32 = this.firstColliderIndices;\n    this.firstColliderIndices = this.stagingFirstColliderIndices;\n    this.stagingFirstColliderIndices = int32;\n    let uint32 = this.firstColliderGenerations;\n    this.firstColliderGenerations = this.stagingFirstColliderGenerations;\n    this.stagingFirstColliderGenerations = uint32;\n    int32 = this.secondColliderIndices;\n    this.secondColliderIndices = this.stagingSecondColliderIndices;\n    this.stagingSecondColliderIndices = int32;\n    uint32 = this.secondColliderGenerations;\n    this.secondColliderGenerations = this.stagingSecondColliderGenerations;\n    this.stagingSecondColliderGenerations = uint32;\n    int32 = this.firstBodyIndices;\n    this.firstBodyIndices = this.stagingFirstBodyIndices;\n    this.stagingFirstBodyIndices = int32;\n    uint32 = this.firstBodyGenerations;\n    this.firstBodyGenerations = this.stagingFirstBodyGenerations;\n    this.stagingFirstBodyGenerations = uint32;\n    int32 = this.secondBodyIndices;\n    this.secondBodyIndices = this.stagingSecondBodyIndices;\n    this.stagingSecondBodyIndices = int32;\n    uint32 = this.secondBodyGenerations;\n    this.secondBodyGenerations = this.stagingSecondBodyGenerations;\n    this.stagingSecondBodyGenerations = uint32;\n    let uint8 = this.sensorFlags;\n    this.sensorFlags = this.stagingSensorFlags;\n    this.stagingSensorFlags = uint8;\n    let float64 = this.mixedFriction;\n    this.mixedFriction = this.stagingMixedFriction;\n    this.stagingMixedFriction = float64;\n    float64 = this.mixedRestitution;\n    this.mixedRestitution = this.stagingMixedRestitution;\n    this.stagingMixedRestitution = float64;\n    float64 = this.normalX;\n    this.normalX = this.stagingNormalX;\n    this.stagingNormalX = float64;\n    float64 = this.normalY;\n    this.normalY = this.stagingNormalY;\n    this.stagingNormalY = float64;\n    int32 = this.firstLeafIndices;\n    this.firstLeafIndices = this.stagingFirstLeafIndices;\n    this.stagingFirstLeafIndices = int32;\n    int32 = this.secondLeafIndices;\n    this.secondLeafIndices = this.stagingSecondLeafIndices;\n    this.stagingSecondLeafIndices = int32;\n    uint8 = this.pointCounts;\n    this.pointCounts = this.stagingPointCounts;\n    this.stagingPointCounts = uint8;\n    float64 = this.pointFirstX;\n    this.pointFirstX = this.stagingPointFirstX;\n    this.stagingPointFirstX = float64;\n    float64 = this.pointFirstY;\n    this.pointFirstY = this.stagingPointFirstY;\n    this.stagingPointFirstY = float64;\n    float64 = this.pointSecondX;\n    this.pointSecondX = this.stagingPointSecondX;\n    this.stagingPointSecondX = float64;\n    float64 = this.pointSecondY;\n    this.pointSecondY = this.stagingPointSecondY;\n    this.stagingPointSecondY = float64;\n    float64 = this.pointSeparations;\n    this.pointSeparations = this.stagingPointSeparations;\n    this.stagingPointSeparations = float64;\n    int32 = this.pointFirstFeatures;\n    this.pointFirstFeatures = this.stagingPointFirstFeatures;\n    this.stagingPointFirstFeatures = int32;\n    int32 = this.pointSecondFeatures;\n    this.pointSecondFeatures = this.stagingPointSecondFeatures;\n    this.stagingPointSecondFeatures = int32;\n    float64 = this.pointNormalImpulses;\n    this.pointNormalImpulses = this.stagingPointNormalImpulses;\n    this.stagingPointNormalImpulses = float64;\n    float64 = this.pointTangentImpulses;\n    this.pointTangentImpulses = this.stagingPointTangentImpulses;\n    this.stagingPointTangentImpulses = float64;\n    this.contactCount = nextCount;\n    this.eventCount = nextEventCount;\n  }\n\n  writeStagingContact(\n    target: number,\n    firstColliderIndex: number,\n    firstColliderGeneration: number,\n    secondColliderIndex: number,\n    secondColliderGeneration: number,\n    colliders: ColliderStore2D,\n    manifold: PrivateManifold2D,\n    oldContact: number,\n  ): void {\n    this.stagingFirstColliderIndices[target] = firstColliderIndex;\n    this.stagingFirstColliderGenerations[target] = firstColliderGeneration;\n    this.stagingSecondColliderIndices[target] = secondColliderIndex;\n    this.stagingSecondColliderGenerations[target] = secondColliderGeneration;\n    this.stagingFirstBodyIndices[target] = colliders.bodyIndices[firstColliderIndex]!;\n    this.stagingFirstBodyGenerations[target] = colliders.bodyGenerations[firstColliderIndex]!;\n    this.stagingSecondBodyIndices[target] = colliders.bodyIndices[secondColliderIndex]!;\n    this.stagingSecondBodyGenerations[target] = colliders.bodyGenerations[secondColliderIndex]!;\n    const sensor =\n      ((colliders.flags[firstColliderIndex]! | colliders.flags[secondColliderIndex]!) & COLLIDER_SENSOR_2D) !== 0;\n    this.stagingSensorFlags[target] = sensor ? 1 : 0;\n    const firstFriction = materialNumberAt(\n      colliders,\n      firstColliderIndex,\n      \"friction\",\n      0.5,\n    );\n    const secondFriction = materialNumberAt(\n      colliders,\n      secondColliderIndex,\n      \"friction\",\n      0.5,\n    );\n    this.stagingMixedFriction[target] = Math.sqrt(\n      firstFriction * secondFriction,\n    );\n    this.stagingMixedRestitution[target] = Math.max(\n      materialNumberAt(colliders, firstColliderIndex, \"restitution\", 0),\n      materialNumberAt(colliders, secondColliderIndex, \"restitution\", 0),\n    );\n    this.stagingNormalX[target] = manifold.normalX;\n    this.stagingNormalY[target] = manifold.normalY;\n    this.stagingFirstLeafIndices[target] = manifold.firstLeaf;\n    this.stagingSecondLeafIndices[target] = manifold.secondLeaf;\n    const pointCount = Math.min(POINTS_PER_CONTACT, manifold.points.length);\n    this.stagingPointCounts[target] = pointCount;\n    let firstPoint = 0;\n    let secondPoint = 1;\n    if (pointCount === 2 && compareManifoldPoints(manifold.points[0]!, manifold.points[1]!) > 0) {\n      firstPoint = 1;\n      secondPoint = 0;\n    }\n    for (let pointIndex = 0; pointIndex < POINTS_PER_CONTACT; pointIndex += 1) {\n      const targetPoint = target * POINTS_PER_CONTACT + pointIndex;\n      if (pointIndex >= pointCount) {\n        clearStagingPoint(this, targetPoint);\n        continue;\n      }\n      const sourcePoint = manifold.points[pointIndex === 0 ? firstPoint : secondPoint]!;\n      this.stagingPointFirstX[targetPoint] = sourcePoint.firstX;\n      this.stagingPointFirstY[targetPoint] = sourcePoint.firstY;\n      this.stagingPointSecondX[targetPoint] = sourcePoint.secondX;\n      this.stagingPointSecondY[targetPoint] = sourcePoint.secondY;\n      this.stagingPointSeparations[targetPoint] = sourcePoint.separation;\n      this.stagingPointFirstFeatures[targetPoint] = sourcePoint.firstFeature;\n      this.stagingPointSecondFeatures[targetPoint] = sourcePoint.secondFeature;\n      const oldPoint = oldContact < 0\n        ? -1\n        : this.findMatchingPoint(oldContact, manifold.firstLeaf, manifold.secondLeaf, sourcePoint.firstFeature, sourcePoint.secondFeature);\n      this.stagingPointNormalImpulses[targetPoint] = oldPoint < 0 ? 0 : this.pointNormalImpulses[oldPoint]!;\n      this.stagingPointTangentImpulses[targetPoint] = oldPoint < 0 ? 0 : this.pointTangentImpulses[oldPoint]!;\n    }\n  }\n\n  private findMatchingPoint(\n    oldContact: number,\n    firstLeaf: number,\n    secondLeaf: number,\n    firstFeature: number,\n    secondFeature: number,\n  ): number {\n    if (\n      this.firstLeafIndices[oldContact] !== firstLeaf ||\n      this.secondLeafIndices[oldContact] !== secondLeaf\n    ) return -1;\n    const base = oldContact * POINTS_PER_CONTACT;\n    for (let point = 0; point < this.pointCounts[oldContact]!; point += 1) {\n      const index = base + point;\n      if (\n        this.pointFirstFeatures[index] === firstFeature &&\n        this.pointSecondFeatures[index] === secondFeature\n      ) return index;\n    }\n    return -1;\n  }\n}\n\nexport function updateSortedContactCache2D(\n  cache: ContactCache2D,\n  pairs: SortedColliderPairs2D,\n  colliders: ColliderStore2D,\n  manifoldProvider: PrivateManifoldProvider2D,\n): void {\n  cache.ensureCapacity(cache.contactCount + pairs.pairCount);\n  cache.ensureEventCapacity(cache.contactCount + pairs.pairCount);\n  let oldContact = 0;\n  let pair = 0;\n  let nextContact = 0;\n  let nextEvent = 0;\n\n  while (oldContact < cache.contactCount || pair < pairs.pairCount) {\n    let firstIndex: number;\n    let firstGeneration: number;\n    let secondIndex: number;\n    let secondGeneration: number;\n    let matchesOld = false;\n    if (oldContact >= cache.contactCount) {\n      firstIndex = pairs.pairFirstColliderIndices[pair]!;\n      firstGeneration = pairs.pairFirstColliderGenerations[pair]!;\n      secondIndex = pairs.pairSecondColliderIndices[pair]!;\n      secondGeneration = pairs.pairSecondColliderGenerations[pair]!;\n      pair += 1;\n    } else if (pair >= pairs.pairCount) {\n      firstIndex = cache.firstColliderIndices[oldContact]!;\n      firstGeneration = cache.firstColliderGenerations[oldContact]!;\n      secondIndex = cache.secondColliderIndices[oldContact]!;\n      secondGeneration = cache.secondColliderGenerations[oldContact]!;\n      matchesOld = true;\n      oldContact += 1;\n    } else {\n      const comparison = compareContactToPair(\n        cache,\n        oldContact,\n        pairs.pairFirstColliderIndices[pair]!,\n        pairs.pairFirstColliderGenerations[pair]!,\n        pairs.pairSecondColliderIndices[pair]!,\n        pairs.pairSecondColliderGenerations[pair]!,\n      );\n      if (comparison <= 0) {\n        firstIndex = cache.firstColliderIndices[oldContact]!;\n        firstGeneration = cache.firstColliderGenerations[oldContact]!;\n        secondIndex = cache.secondColliderIndices[oldContact]!;\n        secondGeneration = cache.secondColliderGenerations[oldContact]!;\n        matchesOld = true;\n        oldContact += 1;\n        if (comparison === 0) pair += 1;\n      } else {\n        firstIndex = pairs.pairFirstColliderIndices[pair]!;\n        firstGeneration = pairs.pairFirstColliderGenerations[pair]!;\n        secondIndex = pairs.pairSecondColliderIndices[pair]!;\n        secondGeneration = pairs.pairSecondColliderGenerations[pair]!;\n        pair += 1;\n      }\n    }\n    const collidersLive =\n      colliders.has(firstIndex, firstGeneration) &&\n      colliders.has(secondIndex, secondGeneration);\n    const sameBody =\n      collidersLive &&\n      colliders.bodyIndices[firstIndex] === colliders.bodyIndices[secondIndex] &&\n      colliders.bodyGenerations[firstIndex] === colliders.bodyGenerations[secondIndex];\n    const manifold = collidersLive && !sameBody\n      ? manifoldProvider(firstIndex, secondIndex)\n      : null;\n    if (manifold !== null && manifold.points.length > 0) {\n      const oldIndex = matchesOld ? oldContact - 1 : -1;\n      const sensor =\n        ((colliders.flags[firstIndex]! | colliders.flags[secondIndex]!) &\n          COLLIDER_SENSOR_2D) !==\n        0;\n      const changesSensorState =\n        oldIndex >= 0 && (cache.sensorFlags[oldIndex] !== 0) !== sensor;\n      cache.writeStagingContact(\n        nextContact,\n        firstIndex,\n        firstGeneration,\n        secondIndex,\n        secondGeneration,\n        colliders,\n        manifold,\n        changesSensorState ? -1 : oldIndex,\n      );\n      if (changesSensorState) {\n        nextEvent = writeEndEvent(cache, nextEvent, oldIndex);\n        nextEvent = writeBeginEvent(cache, nextEvent, nextContact);\n      } else if (!matchesOld) {\n        nextEvent = writeBeginEvent(cache, nextEvent, nextContact);\n      }\n      nextContact += 1;\n    } else if (matchesOld) {\n      nextEvent = writeEndEvent(cache, nextEvent, oldContact - 1);\n    }\n  }\n  cache.swapGenerations(nextContact, nextEvent);\n}\n\nfunction compareContactToPair(\n  cache: ContactCache2D,\n  contact: number,\n  firstIndex: number,\n  firstGeneration: number,\n  secondIndex: number,\n  secondGeneration: number,\n): number {\n  return (\n    compareIdentity(cache.firstColliderIndices[contact]!, cache.firstColliderGenerations[contact]!, firstIndex, firstGeneration) ||\n    compareIdentity(cache.secondColliderIndices[contact]!, cache.secondColliderGenerations[contact]!, secondIndex, secondGeneration)\n  );\n}\n\nfunction compareIdentity(\n  firstIndex: number,\n  firstGeneration: number,\n  secondIndex: number,\n  secondGeneration: number,\n): number {\n  return firstIndex - secondIndex || firstGeneration - secondGeneration;\n}\n\nfunction writeBeginEvent(\n  cache: ContactCache2D,\n  event: number,\n  stagingContact: number,\n): number {\n  cache.eventTypes[event] = cache.stagingSensorFlags[stagingContact] !== 0\n    ? OVERLAP_EVENT_BEGIN_2D\n    : CONTACT_EVENT_BEGIN_2D;\n  cache.eventFirstColliderIndices[event] =\n    cache.stagingFirstColliderIndices[stagingContact]!;\n  cache.eventFirstColliderGenerations[event] =\n    cache.stagingFirstColliderGenerations[stagingContact]!;\n  cache.eventSecondColliderIndices[event] =\n    cache.stagingSecondColliderIndices[stagingContact]!;\n  cache.eventSecondColliderGenerations[event] =\n    cache.stagingSecondColliderGenerations[stagingContact]!;\n  return event + 1;\n}\n\nfunction writeEndEvent(cache: ContactCache2D, event: number, contact: number): number {\n  cache.eventTypes[event] = cache.sensorFlags[contact] !== 0\n    ? OVERLAP_EVENT_END_2D\n    : CONTACT_EVENT_END_2D;\n  cache.eventFirstColliderIndices[event] = cache.firstColliderIndices[contact]!;\n  cache.eventFirstColliderGenerations[event] = cache.firstColliderGenerations[contact]!;\n  cache.eventSecondColliderIndices[event] = cache.secondColliderIndices[contact]!;\n  cache.eventSecondColliderGenerations[event] = cache.secondColliderGenerations[contact]!;\n  return event + 1;\n}\n\nfunction materialNumberAt(\n  colliders: ColliderStore2D,\n  colliderIndex: number,\n  property: \"friction\" | \"restitution\",\n  fallback: number,\n): number {\n  const material = colliders.materials[colliderIndex] as Partial<{\n    friction: number;\n    restitution: number;\n  }> | null;\n  return material?.[property] ?? fallback;\n}\n\nfunction compareManifoldPoints(\n  first: PrivateManifold2D[\"points\"][number],\n  second: PrivateManifold2D[\"points\"][number],\n): number {\n  return (\n    first.firstFeature - second.firstFeature ||\n    first.secondFeature - second.secondFeature ||\n    first.firstX - second.firstX ||\n    first.firstY - second.firstY ||\n    first.secondX - second.secondX ||\n    first.secondY - second.secondY\n  );\n}\n\nfunction clearStagingPoint(cache: ContactCache2D, point: number): void {\n  cache.stagingPointFirstX[point] = 0;\n  cache.stagingPointFirstY[point] = 0;\n  cache.stagingPointSecondX[point] = 0;\n  cache.stagingPointSecondY[point] = 0;\n  cache.stagingPointSeparations[point] = 0;\n  cache.stagingPointFirstFeatures[point] = 0;\n  cache.stagingPointSecondFeatures[point] = 0;\n  cache.stagingPointNormalImpulses[point] = 0;\n  cache.stagingPointTangentImpulses[point] = 0;\n}\n\nfunction normalizedCapacity(initialCapacity: number): number {\n  if (!Number.isInteger(initialCapacity) || initialCapacity < 1) {\n    throw new RangeError(\"initialCapacity must be a positive integer.\");\n  }\n  let capacity = 1;\n  while (capacity < initialCapacity) capacity *= 2;\n  return capacity;\n}\n\nfunction growInt32(source: Int32Array, capacity: number): Int32Array {\n  const result = new Int32Array(capacity);\n  result.set(source);\n  return result;\n}\n\nfunction growUint32(source: Uint32Array, capacity: number): Uint32Array {\n  const result = new Uint32Array(capacity);\n  result.set(source);\n  return result;\n}\n\nfunction growUint8(source: Uint8Array, capacity: number): Uint8Array {\n  const result = new Uint8Array(capacity);\n  result.set(source);\n  return result;\n}\n\nfunction growFloat64(source: Float64Array, capacity: number): Float64Array {\n  const result = new Float64Array(capacity);\n  result.set(source);\n  return result;\n}\n"],
+  "mappings": "AAGO,MAAM,qBAAqB,KAAK;AAEhC,MAAM,yBAAyB;AAC/B,MAAM,uBAAuB;AAC7B,MAAM,yBAAyB;AAC/B,MAAM,uBAAuB;AAEpC,MAAM,qBAAqB;AAepB,MAAM,eAAe;AAAA,EAC1B,eAAe;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA,aAAa;AAAA,EACb;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,kBAAkB,GAAG;AAC/B,UAAM,WAAW,mBAAmB,eAAe;AACnD,SAAK,uBAAuB,IAAI,WAAW,QAAQ;AACnD,SAAK,2BAA2B,IAAI,YAAY,QAAQ;AACxD,SAAK,wBAAwB,IAAI,WAAW,QAAQ;AACpD,SAAK,4BAA4B,IAAI,YAAY,QAAQ;AACzD,SAAK,mBAAmB,IAAI,WAAW,QAAQ;AAC/C,SAAK,uBAAuB,IAAI,YAAY,QAAQ;AACpD,SAAK,oBAAoB,IAAI,WAAW,QAAQ;AAChD,SAAK,wBAAwB,IAAI,YAAY,QAAQ;AACrD,SAAK,cAAc,IAAI,WAAW,QAAQ;AAC1C,SAAK,gBAAgB,IAAI,aAAa,QAAQ;AAC9C,SAAK,mBAAmB,IAAI,aAAa,QAAQ;AACjD,SAAK,UAAU,IAAI,aAAa,QAAQ;AACxC,SAAK,UAAU,IAAI,aAAa,QAAQ;AACxC,SAAK,mBAAmB,IAAI,WAAW,QAAQ;AAC/C,SAAK,oBAAoB,IAAI,WAAW,QAAQ;AAChD,SAAK,cAAc,IAAI,WAAW,QAAQ;AAC1C,SAAK,cAAc,IAAI,aAAa,WAAW,kBAAkB;AACjE,SAAK,cAAc,IAAI,aAAa,WAAW,kBAAkB;AACjE,SAAK,eAAe,IAAI,aAAa,WAAW,kBAAkB;AAClE,SAAK,eAAe,IAAI,aAAa,WAAW,kBAAkB;AAClE,SAAK,mBAAmB,IAAI,aAAa,WAAW,kBAAkB;AACtE,SAAK,qBAAqB,IAAI,WAAW,WAAW,kBAAkB;AACtE,SAAK,sBAAsB,IAAI,WAAW,WAAW,kBAAkB;AACvE,SAAK,sBAAsB,IAAI,aAAa,WAAW,kBAAkB;AACzE,SAAK,uBAAuB,IAAI,aAAa,WAAW,kBAAkB;AAE1E,SAAK,8BAA8B,IAAI,WAAW,QAAQ;AAC1D,SAAK,kCAAkC,IAAI,YAAY,QAAQ;AAC/D,SAAK,+BAA+B,IAAI,WAAW,QAAQ;AAC3D,SAAK,mCAAmC,IAAI,YAAY,QAAQ;AAChE,SAAK,0BAA0B,IAAI,WAAW,QAAQ;AACtD,SAAK,8BAA8B,IAAI,YAAY,QAAQ;AAC3D,SAAK,2BAA2B,IAAI,WAAW,QAAQ;AACvD,SAAK,+BAA+B,IAAI,YAAY,QAAQ;AAC5D,SAAK,qBAAqB,IAAI,WAAW,QAAQ;AACjD,SAAK,uBAAuB,IAAI,aAAa,QAAQ;AACrD,SAAK,0BAA0B,IAAI,aAAa,QAAQ;AACxD,SAAK,iBAAiB,IAAI,aAAa,QAAQ;AAC/C,SAAK,iBAAiB,IAAI,aAAa,QAAQ;AAC/C,SAAK,0BAA0B,IAAI,WAAW,QAAQ;AACtD,SAAK,2BAA2B,IAAI,WAAW,QAAQ;AACvD,SAAK,qBAAqB,IAAI,WAAW,QAAQ;AACjD,SAAK,qBAAqB,IAAI,aAAa,WAAW,kBAAkB;AACxE,SAAK,qBAAqB,IAAI,aAAa,WAAW,kBAAkB;AACxE,SAAK,sBAAsB,IAAI,aAAa,WAAW,kBAAkB;AACzE,SAAK,sBAAsB,IAAI,aAAa,WAAW,kBAAkB;AACzE,SAAK,0BAA0B,IAAI,aAAa,WAAW,kBAAkB;AAC7E,SAAK,4BAA4B,IAAI,WAAW,WAAW,kBAAkB;AAC7E,SAAK,6BAA6B,IAAI,WAAW,WAAW,kBAAkB;AAC9E,SAAK,6BAA6B,IAAI,aAAa,WAAW,kBAAkB;AAChF,SAAK,8BAA8B,IAAI,aAAa,WAAW,kBAAkB;AAEjF,SAAK,aAAa,IAAI,WAAW,WAAW,CAAC;AAC7C,SAAK,4BAA4B,IAAI,WAAW,WAAW,CAAC;AAC5D,SAAK,gCAAgC,IAAI,YAAY,WAAW,CAAC;AACjE,SAAK,6BAA6B,IAAI,WAAW,WAAW,CAAC;AAC7D,SAAK,iCAAiC,IAAI,YAAY,WAAW,CAAC;AAAA,EACpE;AAAA,EAEA,eAAe,UAAwB;AACrC,QAAI,YAAY,KAAK,qBAAqB,OAAQ;AAClD,QAAI,WAAW,KAAK,qBAAqB;AACzC,WAAO,WAAW,SAAU,aAAY;AACxC,SAAK,uBAAuB,UAAU,KAAK,sBAAsB,QAAQ;AACzE,SAAK,2BAA2B,WAAW,KAAK,0BAA0B,QAAQ;AAClF,SAAK,wBAAwB,UAAU,KAAK,uBAAuB,QAAQ;AAC3E,SAAK,4BAA4B,WAAW,KAAK,2BAA2B,QAAQ;AACpF,SAAK,mBAAmB,UAAU,KAAK,kBAAkB,QAAQ;AACjE,SAAK,uBAAuB,WAAW,KAAK,sBAAsB,QAAQ;AAC1E,SAAK,oBAAoB,UAAU,KAAK,mBAAmB,QAAQ;AACnE,SAAK,wBAAwB,WAAW,KAAK,uBAAuB,QAAQ;AAC5E,SAAK,cAAc,UAAU,KAAK,aAAa,QAAQ;AACvD,SAAK,gBAAgB,YAAY,KAAK,eAAe,QAAQ;AAC7D,SAAK,mBAAmB,YAAY,KAAK,kBAAkB,QAAQ;AACnE,SAAK,UAAU,YAAY,KAAK,SAAS,QAAQ;AACjD,SAAK,UAAU,YAAY,KAAK,SAAS,QAAQ;AACjD,SAAK,mBAAmB,UAAU,KAAK,kBAAkB,QAAQ;AACjE,SAAK,oBAAoB,UAAU,KAAK,mBAAmB,QAAQ;AACnE,SAAK,cAAc,UAAU,KAAK,aAAa,QAAQ;AACvD,SAAK,cAAc,YAAY,KAAK,aAAa,WAAW,kBAAkB;AAC9E,SAAK,cAAc,YAAY,KAAK,aAAa,WAAW,kBAAkB;AAC9E,SAAK,eAAe,YAAY,KAAK,cAAc,WAAW,kBAAkB;AAChF,SAAK,eAAe,YAAY,KAAK,cAAc,WAAW,kBAAkB;AAChF,SAAK,mBAAmB,YAAY,KAAK,kBAAkB,WAAW,kBAAkB;AACxF,SAAK,qBAAqB,UAAU,KAAK,oBAAoB,WAAW,kBAAkB;AAC1F,SAAK,sBAAsB,UAAU,KAAK,qBAAqB,WAAW,kBAAkB;AAC5F,SAAK,sBAAsB,YAAY,KAAK,qBAAqB,WAAW,kBAAkB;AAC9F,SAAK,uBAAuB,YAAY,KAAK,sBAAsB,WAAW,kBAAkB;AAEhG,SAAK,8BAA8B,UAAU,KAAK,6BAA6B,QAAQ;AACvF,SAAK,kCAAkC,WAAW,KAAK,iCAAiC,QAAQ;AAChG,SAAK,+BAA+B,UAAU,KAAK,8BAA8B,QAAQ;AACzF,SAAK,mCAAmC,WAAW,KAAK,kCAAkC,QAAQ;AAClG,SAAK,0BAA0B,UAAU,KAAK,yBAAyB,QAAQ;AAC/E,SAAK,8BAA8B,WAAW,KAAK,6BAA6B,QAAQ;AACxF,SAAK,2BAA2B,UAAU,KAAK,0BAA0B,QAAQ;AACjF,SAAK,+BAA+B,WAAW,KAAK,8BAA8B,QAAQ;AAC1F,SAAK,qBAAqB,UAAU,KAAK,oBAAoB,QAAQ;AACrE,SAAK,uBAAuB,YAAY,KAAK,sBAAsB,QAAQ;AAC3E,SAAK,0BAA0B,YAAY,KAAK,yBAAyB,QAAQ;AACjF,SAAK,iBAAiB,YAAY,KAAK,gBAAgB,QAAQ;AAC/D,SAAK,iBAAiB,YAAY,KAAK,gBAAgB,QAAQ;AAC/D,SAAK,0BAA0B,UAAU,KAAK,yBAAyB,QAAQ;AAC/E,SAAK,2BAA2B,UAAU,KAAK,0BAA0B,QAAQ;AACjF,SAAK,qBAAqB,UAAU,KAAK,oBAAoB,QAAQ;AACrE,SAAK,qBAAqB,YAAY,KAAK,oBAAoB,WAAW,kBAAkB;AAC5F,SAAK,qBAAqB,YAAY,KAAK,oBAAoB,WAAW,kBAAkB;AAC5F,SAAK,sBAAsB,YAAY,KAAK,qBAAqB,WAAW,kBAAkB;AAC9F,SAAK,sBAAsB,YAAY,KAAK,qBAAqB,WAAW,kBAAkB;AAC9F,SAAK,0BAA0B,YAAY,KAAK,yBAAyB,WAAW,kBAAkB;AACtG,SAAK,4BAA4B,UAAU,KAAK,2BAA2B,WAAW,kBAAkB;AACxG,SAAK,6BAA6B,UAAU,KAAK,4BAA4B,WAAW,kBAAkB;AAC1G,SAAK,6BAA6B,YAAY,KAAK,4BAA4B,WAAW,kBAAkB;AAC5G,SAAK,8BAA8B,YAAY,KAAK,6BAA6B,WAAW,kBAAkB;AAC9G,SAAK,oBAAoB,WAAW,CAAC;AAAA,EACvC;AAAA,EAEA,oBAAoB,UAAwB;AAC1C,QAAI,YAAY,KAAK,WAAW,OAAQ;AACxC,QAAI,WAAW,KAAK,WAAW;AAC/B,WAAO,WAAW,SAAU,aAAY;AACxC,SAAK,aAAa,UAAU,KAAK,YAAY,QAAQ;AACrD,SAAK,4BAA4B,UAAU,KAAK,2BAA2B,QAAQ;AACnF,SAAK,gCAAgC,WAAW,KAAK,+BAA+B,QAAQ;AAC5F,SAAK,6BAA6B,UAAU,KAAK,4BAA4B,QAAQ;AACrF,SAAK,iCAAiC,WAAW,KAAK,gCAAgC,QAAQ;AAAA,EAChG;AAAA,EAEA,gBAAgB,WAAmB,gBAA8B;AAC/D,QAAI,QAAQ,KAAK;AACjB,SAAK,uBAAuB,KAAK;AACjC,SAAK,8BAA8B;AACnC,QAAI,SAAS,KAAK;AAClB,SAAK,2BAA2B,KAAK;AACrC,SAAK,kCAAkC;AACvC,YAAQ,KAAK;AACb,SAAK,wBAAwB,KAAK;AAClC,SAAK,+BAA+B;AACpC,aAAS,KAAK;AACd,SAAK,4BAA4B,KAAK;AACtC,SAAK,mCAAmC;AACxC,YAAQ,KAAK;AACb,SAAK,mBAAmB,KAAK;AAC7B,SAAK,0BAA0B;AAC/B,aAAS,KAAK;AACd,SAAK,uBAAuB,KAAK;AACjC,SAAK,8BAA8B;AACnC,YAAQ,KAAK;AACb,SAAK,oBAAoB,KAAK;AAC9B,SAAK,2BAA2B;AAChC,aAAS,KAAK;AACd,SAAK,wBAAwB,KAAK;AAClC,SAAK,+BAA+B;AACpC,QAAI,QAAQ,KAAK;AACjB,SAAK,cAAc,KAAK;AACxB,SAAK,qBAAqB;AAC1B,QAAI,UAAU,KAAK;AACnB,SAAK,gBAAgB,KAAK;AAC1B,SAAK,uBAAuB;AAC5B,cAAU,KAAK;AACf,SAAK,mBAAmB,KAAK;AAC7B,SAAK,0BAA0B;AAC/B,cAAU,KAAK;AACf,SAAK,UAAU,KAAK;AACpB,SAAK,iBAAiB;AACtB,cAAU,KAAK;AACf,SAAK,UAAU,KAAK;AACpB,SAAK,iBAAiB;AACtB,YAAQ,KAAK;AACb,SAAK,mBAAmB,KAAK;AAC7B,SAAK,0BAA0B;AAC/B,YAAQ,KAAK;AACb,SAAK,oBAAoB,KAAK;AAC9B,SAAK,2BAA2B;AAChC,YAAQ,KAAK;AACb,SAAK,cAAc,KAAK;AACxB,SAAK,qBAAqB;AAC1B,cAAU,KAAK;AACf,SAAK,cAAc,KAAK;AACxB,SAAK,qBAAqB;AAC1B,cAAU,KAAK;AACf,SAAK,cAAc,KAAK;AACxB,SAAK,qBAAqB;AAC1B,cAAU,KAAK;AACf,SAAK,eAAe,KAAK;AACzB,SAAK,sBAAsB;AAC3B,cAAU,KAAK;AACf,SAAK,eAAe,KAAK;AACzB,SAAK,sBAAsB;AAC3B,cAAU,KAAK;AACf,SAAK,mBAAmB,KAAK;AAC7B,SAAK,0BAA0B;AAC/B,YAAQ,KAAK;AACb,SAAK,qBAAqB,KAAK;AAC/B,SAAK,4BAA4B;AACjC,YAAQ,KAAK;AACb,SAAK,sBAAsB,KAAK;AAChC,SAAK,6BAA6B;AAClC,cAAU,KAAK;AACf,SAAK,sBAAsB,KAAK;AAChC,SAAK,6BAA6B;AAClC,cAAU,KAAK;AACf,SAAK,uBAAuB,KAAK;AACjC,SAAK,8BAA8B;AACnC,SAAK,eAAe;AACpB,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,oBACE,QACA,oBACA,yBACA,qBACA,0BACA,WACA,UACA,YACM;AACN,SAAK,4BAA4B,MAAM,IAAI;AAC3C,SAAK,gCAAgC,MAAM,IAAI;AAC/C,SAAK,6BAA6B,MAAM,IAAI;AAC5C,SAAK,iCAAiC,MAAM,IAAI;AAChD,SAAK,wBAAwB,MAAM,IAAI,UAAU,YAAY,kBAAkB;AAC/E,SAAK,4BAA4B,MAAM,IAAI,UAAU,gBAAgB,kBAAkB;AACvF,SAAK,yBAAyB,MAAM,IAAI,UAAU,YAAY,mBAAmB;AACjF,SAAK,6BAA6B,MAAM,IAAI,UAAU,gBAAgB,mBAAmB;AACzF,UAAM,WACF,UAAU,MAAM,kBAAkB,IAAK,UAAU,MAAM,mBAAmB,KAAM,wBAAwB;AAC5G,SAAK,mBAAmB,MAAM,IAAI,SAAS,IAAI;AAC/C,UAAM,gBAAgB;AAAA,MACpB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,UAAM,iBAAiB;AAAA,MACrB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,SAAK,qBAAqB,MAAM,IAAI,KAAK;AAAA,MACvC,gBAAgB;AAAA,IAClB;AACA,SAAK,wBAAwB,MAAM,IAAI,KAAK;AAAA,MAC1C,iBAAiB,WAAW,oBAAoB,eAAe,CAAC;AAAA,MAChE,iBAAiB,WAAW,qBAAqB,eAAe,CAAC;AAAA,IACnE;AACA,SAAK,eAAe,MAAM,IAAI,SAAS;AACvC,SAAK,eAAe,MAAM,IAAI,SAAS;AACvC,SAAK,wBAAwB,MAAM,IAAI,SAAS;AAChD,SAAK,yBAAyB,MAAM,IAAI,SAAS;AACjD,UAAM,aAAa,KAAK,IAAI,oBAAoB,SAAS,OAAO,MAAM;AACtE,SAAK,mBAAmB,MAAM,IAAI;AAClC,QAAI,aAAa;AACjB,QAAI,cAAc;AAClB,QAAI,eAAe,KAAK,sBAAsB,SAAS,OAAO,CAAC,GAAI,SAAS,OAAO,CAAC,CAAE,IAAI,GAAG;AAC3F,mBAAa;AACb,oBAAc;AAAA,IAChB;AACA,aAAS,aAAa,GAAG,aAAa,oBAAoB,cAAc,GAAG;AACzE,YAAM,cAAc,SAAS,qBAAqB;AAClD,UAAI,cAAc,YAAY;AAC5B,0BAAkB,MAAM,WAAW;AACnC;AAAA,MACF;AACA,YAAM,cAAc,SAAS,OAAO,eAAe,IAAI,aAAa,WAAW;AAC/E,WAAK,mBAAmB,WAAW,IAAI,YAAY;AACnD,WAAK,mBAAmB,WAAW,IAAI,YAAY;AACnD,WAAK,oBAAoB,WAAW,IAAI,YAAY;AACpD,WAAK,oBAAoB,WAAW,IAAI,YAAY;AACpD,WAAK,wBAAwB,WAAW,IAAI,YAAY;AACxD,WAAK,0BAA0B,WAAW,IAAI,YAAY;AAC1D,WAAK,2BAA2B,WAAW,IAAI,YAAY;AAC3D,YAAM,WAAW,aAAa,IAC1B,KACA,KAAK,kBAAkB,YAAY,SAAS,WAAW,SAAS,YAAY,YAAY,cAAc,YAAY,aAAa;AACnI,WAAK,2BAA2B,WAAW,IAAI,WAAW,IAAI,IAAI,KAAK,oBAAoB,QAAQ;AACnG,WAAK,4BAA4B,WAAW,IAAI,WAAW,IAAI,IAAI,KAAK,qBAAqB,QAAQ;AAAA,IACvG;AAAA,EACF;AAAA,EAEQ,kBACN,YACA,WACA,YACA,cACA,eACQ;AACR,QACE,KAAK,iBAAiB,UAAU,MAAM,aACtC,KAAK,kBAAkB,UAAU,MAAM,WACvC,QAAO;AACT,UAAM,OAAO,aAAa;AAC1B,aAAS,QAAQ,GAAG,QAAQ,KAAK,YAAY,UAAU,GAAI,SAAS,GAAG;AACrE,YAAM,QAAQ,OAAO;AACrB,UACE,KAAK,mBAAmB,KAAK,MAAM,gBACnC,KAAK,oBAAoB,KAAK,MAAM,cACpC,QAAO;AAAA,IACX;AACA,WAAO;AAAA,EACT;AACF;AAEO,SAAS,2BACd,OACA,OACA,WACA,kBACM;AACN,QAAM,eAAe,MAAM,eAAe,MAAM,SAAS;AACzD,QAAM,oBAAoB,MAAM,eAAe,MAAM,SAAS;AAC9D,MAAI,aAAa;AACjB,MAAI,OAAO;AACX,MAAI,cAAc;AAClB,MAAI,YAAY;AAEhB,SAAO,aAAa,MAAM,gBAAgB,OAAO,MAAM,WAAW;AAChE,QAAI;AACJ,QAAI;AACJ,QAAI;AACJ,QAAI;AACJ,QAAI,aAAa;AACjB,QAAI,cAAc,MAAM,cAAc;AACpC,mBAAa,MAAM,yBAAyB,IAAI;AAChD,wBAAkB,MAAM,6BAA6B,IAAI;AACzD,oBAAc,MAAM,0BAA0B,IAAI;AAClD,yBAAmB,MAAM,8BAA8B,IAAI;AAC3D,cAAQ;AAAA,IACV,WAAW,QAAQ,MAAM,WAAW;AAClC,mBAAa,MAAM,qBAAqB,UAAU;AAClD,wBAAkB,MAAM,yBAAyB,UAAU;AAC3D,oBAAc,MAAM,sBAAsB,UAAU;AACpD,yBAAmB,MAAM,0BAA0B,UAAU;AAC7D,mBAAa;AACb,oBAAc;AAAA,IAChB,OAAO;AACL,YAAM,aAAa;AAAA,QACjB;AAAA,QACA;AAAA,QACA,MAAM,yBAAyB,IAAI;AAAA,QACnC,MAAM,6BAA6B,IAAI;AAAA,QACvC,MAAM,0BAA0B,IAAI;AAAA,QACpC,MAAM,8BAA8B,IAAI;AAAA,MAC1C;AACA,UAAI,cAAc,GAAG;AACnB,qBAAa,MAAM,qBAAqB,UAAU;AAClD,0BAAkB,MAAM,yBAAyB,UAAU;AAC3D,sBAAc,MAAM,sBAAsB,UAAU;AACpD,2BAAmB,MAAM,0BAA0B,UAAU;AAC7D,qBAAa;AACb,sBAAc;AACd,YAAI,eAAe,EAAG,SAAQ;AAAA,MAChC,OAAO;AACL,qBAAa,MAAM,yBAAyB,IAAI;AAChD,0BAAkB,MAAM,6BAA6B,IAAI;AACzD,sBAAc,MAAM,0BAA0B,IAAI;AAClD,2BAAmB,MAAM,8BAA8B,IAAI;AAC3D,gBAAQ;AAAA,MACV;AAAA,IACF;AACA,UAAM,gBACJ,UAAU,IAAI,YAAY,eAAe,KACzC,UAAU,IAAI,aAAa,gBAAgB;AAC7C,UAAM,WACJ,iBACA,UAAU,YAAY,UAAU,MAAM,UAAU,YAAY,WAAW,KACvE,UAAU,gBAAgB,UAAU,MAAM,UAAU,gBAAgB,WAAW;AACjF,UAAM,WAAW,iBAAiB,CAAC,WAC/B,iBAAiB,YAAY,WAAW,IACxC;AACJ,QAAI,aAAa,QAAQ,SAAS,OAAO,SAAS,GAAG;AACnD,YAAM,WAAW,aAAa,aAAa,IAAI;AAC/C,YAAM,WACF,UAAU,MAAM,UAAU,IAAK,UAAU,MAAM,WAAW,KAC1D,wBACF;AACF,YAAM,qBACJ,YAAY,KAAM,MAAM,YAAY,QAAQ,MAAM,MAAO;AAC3D,YAAM;AAAA,QACJ;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,qBAAqB,KAAK;AAAA,MAC5B;AACA,UAAI,oBAAoB;AACtB,oBAAY,cAAc,OAAO,WAAW,QAAQ;AACpD,oBAAY,gBAAgB,OAAO,WAAW,WAAW;AAAA,MAC3D,WAAW,CAAC,YAAY;AACtB,oBAAY,gBAAgB,OAAO,WAAW,WAAW;AAAA,MAC3D;AACA,qBAAe;AAAA,IACjB,WAAW,YAAY;AACrB,kBAAY,cAAc,OAAO,WAAW,aAAa,CAAC;AAAA,IAC5D;AAAA,EACF;AACA,QAAM,gBAAgB,aAAa,SAAS;AAC9C;AAEA,SAAS,qBACP,OACA,SACA,YACA,iBACA,aACA,kBACQ;AACR,SACE,gBAAgB,MAAM,qBAAqB,OAAO,GAAI,MAAM,yBAAyB,OAAO,GAAI,YAAY,eAAe,KAC3H,gBAAgB,MAAM,sBAAsB,OAAO,GAAI,MAAM,0BAA0B,OAAO,GAAI,aAAa,gBAAgB;AAEnI;AAEA,SAAS,gBACP,YACA,iBACA,aACA,kBACQ;AACR,SAAO,aAAa,eAAe,kBAAkB;AACvD;AAEA,SAAS,gBACP,OACA,OACA,gBACQ;AACR,QAAM,WAAW,KAAK,IAAI,MAAM,mBAAmB,cAAc,MAAM,IACnE,yBACA;AACJ,QAAM,0BAA0B,KAAK,IACnC,MAAM,4BAA4B,cAAc;AAClD,QAAM,8BAA8B,KAAK,IACvC,MAAM,gCAAgC,cAAc;AACtD,QAAM,2BAA2B,KAAK,IACpC,MAAM,6BAA6B,cAAc;AACnD,QAAM,+BAA+B,KAAK,IACxC,MAAM,iCAAiC,cAAc;AACvD,SAAO,QAAQ;AACjB;AAEA,SAAS,cAAc,OAAuB,OAAe,SAAyB;AACpF,QAAM,WAAW,KAAK,IAAI,MAAM,YAAY,OAAO,MAAM,IACrD,uBACA;AACJ,QAAM,0BAA0B,KAAK,IAAI,MAAM,qBAAqB,OAAO;AAC3E,QAAM,8BAA8B,KAAK,IAAI,MAAM,yBAAyB,OAAO;AACnF,QAAM,2BAA2B,KAAK,IAAI,MAAM,sBAAsB,OAAO;AAC7E,QAAM,+BAA+B,KAAK,IAAI,MAAM,0BAA0B,OAAO;AACrF,SAAO,QAAQ;AACjB;AAEA,SAAS,iBACP,WACA,eACA,UACA,UACQ;AACR,QAAM,WAAW,UAAU,UAAU,aAAa;AAIlD,SAAO,WAAW,QAAQ,KAAK;AACjC;AAEA,SAAS,sBACP,OACA,QACQ;AACR,SACE,MAAM,eAAe,OAAO,gBAC5B,MAAM,gBAAgB,OAAO,iBAC7B,MAAM,SAAS,OAAO,UACtB,MAAM,SAAS,OAAO,UACtB,MAAM,UAAU,OAAO,WACvB,MAAM,UAAU,OAAO;AAE3B;AAEA,SAAS,kBAAkB,OAAuB,OAAqB;AACrE,QAAM,mBAAmB,KAAK,IAAI;AAClC,QAAM,mBAAmB,KAAK,IAAI;AAClC,QAAM,oBAAoB,KAAK,IAAI;AACnC,QAAM,oBAAoB,KAAK,IAAI;AACnC,QAAM,wBAAwB,KAAK,IAAI;AACvC,QAAM,0BAA0B,KAAK,IAAI;AACzC,QAAM,2BAA2B,KAAK,IAAI;AAC1C,QAAM,2BAA2B,KAAK,IAAI;AAC1C,QAAM,4BAA4B,KAAK,IAAI;AAC7C;AAEA,SAAS,mBAAmB,iBAAiC;AAC3D,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,kBAAkB,GAAG;AAC7D,UAAM,IAAI,WAAW,6CAA6C;AAAA,EACpE;AACA,MAAI,WAAW;AACf,SAAO,WAAW,gBAAiB,aAAY;AAC/C,SAAO;AACT;AAEA,SAAS,UAAU,QAAoB,UAA8B;AACnE,QAAM,SAAS,IAAI,WAAW,QAAQ;AACtC,SAAO,IAAI,MAAM;AACjB,SAAO;AACT;AAEA,SAAS,WAAW,QAAqB,UAA+B;AACtE,QAAM,SAAS,IAAI,YAAY,QAAQ;AACvC,SAAO,IAAI,MAAM;AACjB,SAAO;AACT;AAEA,SAAS,UAAU,QAAoB,UAA8B;AACnE,QAAM,SAAS,IAAI,WAAW,QAAQ;AACtC,SAAO,IAAI,MAAM;AACjB,SAAO;AACT;AAEA,SAAS,YAAY,QAAsB,UAAgC;AACzE,QAAM,SAAS,IAAI,aAAa,QAAQ;AACxC,SAAO,IAAI,MAAM;AACjB,SAAO;AACT;",
+  "names": []
+}

package/dist/features/physics/lib/2d/world/integrator.d.ts

@@ -0,0 +1,11 @@
+import type { BodyStore2D } from "./storage.js";
+export declare const BODY_TYPE_DYNAMIC_2D: number;
+export declare const BODY_TYPE_KINEMATIC_2D: number;
+export declare const BODY_FIXED_ROTATION_2D: number;
+export declare function applyForceAtPointToCandidateBody2D(bodies: BodyStore2D, bodyIndex: number, bodyGeneration: number, forceX: number, forceY: number, pointX: number, pointY: number): boolean;
+export declare function applyTorqueToCandidateBody2D(bodies: BodyStore2D, bodyIndex: number, bodyGeneration: number, torque: number): boolean;
+export declare function applyImpulseAtPointToCandidateBody2D(bodies: BodyStore2D, bodyIndex: number, bodyGeneration: number, impulseX: number, impulseY: number, pointX: number, pointY: number): boolean;
+export declare function integrateCandidateBodies2D(bodies: BodyStore2D, bodyIndices: Int32Array, bodyCount: number, gravityX: number, gravityY: number, dt: number): void;
+/** Integrate acceleration separately so resting constraints act before position drift. */
+export declare function integrateCandidateVelocities2D(bodies: BodyStore2D, bodyIndices: Int32Array, bodyCount: number, gravityX: number, gravityY: number, dt: number): void;
+export declare function integrateCandidatePoses2D(bodies: BodyStore2D, bodyIndices: Int32Array, bodyCount: number, dt: number): void;