@pibbl/core 0.0.1

package/dist/features/physics/lib/2d/world/broad-phase.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/world/broad-phase.ts"],
+  "sourcesContent": ["import { FAT_AABB_MARGIN } from \"../numeric-policy.js\";\nimport type { PhysicsOwnershipCounters2D } from \"../runtime/ownership.js\";\n\nconst NO_INDEX = -1;\nconst FREE_HEIGHT = -1;\nconst MAX_PROXY_INDEX = 0x7fff_ffff;\nconst MAX_GENERATION = 0xffff_ffff;\n\nexport class DynamicAabbBroadPhase2D {\n  proxyColliderIndices: Int32Array;\n  proxyColliderGenerations: Uint32Array;\n  proxyNodes: Int32Array;\n  proxyGenerations: Uint32Array;\n  proxyMoved: Uint8Array;\n\n  nodeParents: Int32Array;\n  nodeChild1: Int32Array;\n  nodeChild2: Int32Array;\n  nodeHeights: Int32Array;\n  nodeProxyIndices: Int32Array;\n  nodeMinProxyIndices: Int32Array;\n  nodeMinX: Float64Array;\n  nodeMinY: Float64Array;\n  nodeMaxX: Float64Array;\n  nodeMaxY: Float64Array;\n  nodeGenerations: Uint32Array;\n  nodeActive: Uint8Array;\n\n  pairFirstColliderIndices: Int32Array;\n  pairFirstColliderGenerations: Uint32Array;\n  pairSecondColliderIndices: Int32Array;\n  pairSecondColliderGenerations: Uint32Array;\n  pairCount = 0;\n  rootNode = NO_INDEX;\n\n  private proxyActive: Uint8Array;\n  private proxyNextFree: Int32Array;\n  private proxyFreeHead = NO_INDEX;\n  private colliderProxyIndices: Int32Array;\n  private nodeNextFree: Int32Array;\n  private nodeFreeHead = NO_INDEX;\n  private movedBuffer: Int32Array;\n  private movedCount = 0;\n  private queryStack: Int32Array;\n\n  constructor(\n    public readonly counters: PhysicsOwnershipCounters2D,\n    initialProxyCapacity = 4,\n    initialNodeCapacity = 8,\n  ) {\n    const proxyCapacity = normalizedCapacity(initialProxyCapacity);\n    const nodeCapacity = normalizedCapacity(initialNodeCapacity);\n    this.proxyColliderIndices = filledInt32(proxyCapacity, NO_INDEX);\n    this.proxyColliderGenerations = new Uint32Array(proxyCapacity);\n    this.proxyNodes = filledInt32(proxyCapacity, NO_INDEX);\n    this.proxyGenerations = new Uint32Array(proxyCapacity);\n    this.proxyMoved = new Uint8Array(proxyCapacity);\n    this.proxyActive = new Uint8Array(proxyCapacity);\n    this.proxyNextFree = createFreeList(proxyCapacity, 0);\n    this.proxyFreeHead = 0;\n    this.colliderProxyIndices = filledInt32(proxyCapacity, NO_INDEX);\n\n    this.nodeParents = filledInt32(nodeCapacity, NO_INDEX);\n    this.nodeChild1 = filledInt32(nodeCapacity, NO_INDEX);\n    this.nodeChild2 = filledInt32(nodeCapacity, NO_INDEX);\n    this.nodeHeights = filledInt32(nodeCapacity, FREE_HEIGHT);\n    this.nodeProxyIndices = filledInt32(nodeCapacity, NO_INDEX);\n    this.nodeMinProxyIndices = filledInt32(nodeCapacity, MAX_PROXY_INDEX);\n    this.nodeMinX = new Float64Array(nodeCapacity);\n    this.nodeMinY = new Float64Array(nodeCapacity);\n    this.nodeMaxX = new Float64Array(nodeCapacity);\n    this.nodeMaxY = new Float64Array(nodeCapacity);\n    this.nodeGenerations = new Uint32Array(nodeCapacity);\n    this.nodeActive = new Uint8Array(nodeCapacity);\n    this.nodeNextFree = createFreeList(nodeCapacity, 0);\n    this.nodeFreeHead = 0;\n\n    this.movedBuffer = new Int32Array(proxyCapacity);\n    const pairCapacity = normalizedCapacity(proxyCapacity * 2);\n    this.pairFirstColliderIndices = new Int32Array(pairCapacity);\n    this.pairFirstColliderGenerations = new Uint32Array(pairCapacity);\n    this.pairSecondColliderIndices = new Int32Array(pairCapacity);\n    this.pairSecondColliderGenerations = new Uint32Array(pairCapacity);\n    this.queryStack = new Int32Array(nodeCapacity);\n\n    counters.proxyCapacity = proxyCapacity;\n    counters.freeProxySlots = proxyCapacity;\n    counters.colliderProxyMapCapacity = proxyCapacity;\n    counters.treeNodeCapacity = nodeCapacity;\n    counters.freeTreeNodeSlots = nodeCapacity;\n    counters.movedBufferCapacity = proxyCapacity;\n    counters.pairBufferCapacity = pairCapacity;\n    counters.queryStackCapacity = nodeCapacity;\n  }\n\n  get proxyCapacity(): number {\n    return this.proxyActive.length;\n  }\n\n  get nodeCapacity(): number {\n    return this.nodeActive.length;\n  }\n\n  createProxy(\n    colliderIndex: number,\n    colliderGeneration: number,\n    minX: number,\n    minY: number,\n    maxX: number,\n    maxY: number,\n  ): number {\n    this.ensureColliderProxyCapacity(colliderIndex + 1);\n    if (this.colliderProxyIndices[colliderIndex] !== NO_INDEX) {\n      throw new Error(\"collider already has a live broad-phase proxy.\");\n    }\n    if (this.proxyFreeHead === NO_INDEX) this.growProxies();\n    const proxy = this.proxyFreeHead;\n    this.proxyFreeHead = this.proxyNextFree[proxy]!;\n    this.proxyNextFree[proxy] = NO_INDEX;\n    this.proxyActive[proxy] = 1;\n    this.proxyGenerations[proxy] = nextGeneration(\n      this.proxyGenerations[proxy]!,\n    );\n    this.proxyColliderIndices[proxy] = colliderIndex;\n    this.proxyColliderGenerations[proxy] = colliderGeneration;\n    this.colliderProxyIndices[colliderIndex] = proxy;\n    const node = this.allocateNode();\n    this.proxyNodes[proxy] = node;\n    this.nodeProxyIndices[node] = proxy;\n    this.nodeMinProxyIndices[node] = proxy;\n    this.nodeHeights[node] = 0;\n    this.setFatBounds(node, minX, minY, maxX, maxY, 0, 0);\n    this.insertLeaf(node);\n    this.bufferMove(proxy);\n    this.counters.proxyAllocations += 1;\n    this.counters.liveProxies += 1;\n    this.counters.freeProxySlots -= 1;\n    return proxy;\n  }\n\n  hasProxy(proxy: number, generation: number): boolean {\n    return (\n      Number.isInteger(proxy) &&\n      proxy >= 0 &&\n      proxy < this.proxyActive.length &&\n      this.proxyActive[proxy] === 1 &&\n      this.proxyGenerations[proxy] === generation\n    );\n  }\n\n  readFatBoundsInto(\n    proxy: number,\n    generation: number,\n    output: Float64Array,\n    outputOffset: number,\n  ): boolean {\n    if (!this.hasProxy(proxy, generation)) return false;\n    const node = this.proxyNodes[proxy]!;\n    output[outputOffset] = this.nodeMinX[node]!;\n    output[outputOffset + 1] = this.nodeMinY[node]!;\n    output[outputOffset + 2] = this.nodeMaxX[node]!;\n    output[outputOffset + 3] = this.nodeMaxY[node]!;\n    return true;\n  }\n\n  moveProxy(\n    proxy: number,\n    generation: number,\n    minX: number,\n    minY: number,\n    maxX: number,\n    maxY: number,\n    displacementX: number,\n    displacementY: number,\n  ): boolean {\n    if (!this.hasProxy(proxy, generation)) return false;\n    const node = this.proxyNodes[proxy]!;\n    if (\n      this.nodeMinX[node]! <= minX &&\n      this.nodeMinY[node]! <= minY &&\n      this.nodeMaxX[node]! >= maxX &&\n      this.nodeMaxY[node]! >= maxY\n    ) {\n      return false;\n    }\n    this.removeLeaf(node);\n    this.setFatBounds(\n      node,\n      minX,\n      minY,\n      maxX,\n      maxY,\n      displacementX,\n      displacementY,\n    );\n    this.insertLeaf(node);\n    this.bufferMove(proxy);\n    return true;\n  }\n\n  destroyProxy(proxy: number, generation: number): boolean {\n    if (!this.hasProxy(proxy, generation)) return false;\n    if (this.proxyMoved[proxy] === 1) this.unbufferMove(proxy);\n    const node = this.proxyNodes[proxy]!;\n    this.removeLeaf(node);\n    this.releaseNode(node);\n    this.proxyActive[proxy] = 0;\n    this.colliderProxyIndices[this.proxyColliderIndices[proxy]!] = NO_INDEX;\n    this.proxyColliderIndices[proxy] = NO_INDEX;\n    this.proxyColliderGenerations[proxy] = 0;\n    this.proxyNodes[proxy] = NO_INDEX;\n    this.proxyMoved[proxy] = 0;\n    this.counters.proxyReleases += 1;\n    this.counters.liveProxies -= 1;\n    if (generation === MAX_GENERATION) {\n      this.proxyNextFree[proxy] = NO_INDEX;\n      this.counters.retiredProxySlots += 1;\n    } else {\n      this.proxyNextFree[proxy] = this.proxyFreeHead;\n      this.proxyFreeHead = proxy;\n      this.counters.freeProxySlots += 1;\n    }\n    return true;\n  }\n\n  publishPairs(): number {\n    this.pairCount = 0;\n    for (let movedIndex = 0; movedIndex < this.movedCount; movedIndex += 1) {\n      const proxy = this.movedBuffer[movedIndex]!;\n      if (this.proxyActive[proxy] === 1) this.appendPairsForProxy(proxy);\n    }\n    this.sortPairs();\n    this.deduplicatePairs();\n    this.counters.publishedPairs = this.pairCount;\n    for (let movedIndex = 0; movedIndex < this.movedCount; movedIndex += 1) {\n      this.proxyMoved[this.movedBuffer[movedIndex]!] = 0;\n    }\n    this.movedCount = 0;\n    this.counters.movedProxies = 0;\n    return this.pairCount;\n  }\n\n  queryAabbInto(\n    minX: number,\n    minY: number,\n    maxX: number,\n    maxY: number,\n    output: Int32Array,\n    outputOffset: number,\n    maxCount: number,\n  ): number {\n    if (this.rootNode === NO_INDEX || maxCount <= 0) return 0;\n    let stackCount = 0;\n    this.ensureQueryStackCapacity(1);\n    this.queryStack[stackCount] = this.rootNode;\n    stackCount += 1;\n    let count = 0;\n    while (stackCount > 0) {\n      stackCount -= 1;\n      const node = this.queryStack[stackCount]!;\n      if (!this.overlaps(node, minX, minY, maxX, maxY)) continue;\n      const proxy = this.nodeProxyIndices[node]!;\n      if (proxy !== NO_INDEX) {\n        if (count < maxCount && outputOffset + count < output.length) {\n          output[outputOffset + count] = proxy;\n          count += 1;\n        }\n        continue;\n      }\n      this.ensureQueryStackCapacity(stackCount + 2);\n      this.queryStack[stackCount] = this.nodeChild1[node]!;\n      this.queryStack[stackCount + 1] = this.nodeChild2[node]!;\n      stackCount += 2;\n    }\n    sortInt32Range(output, outputOffset, count);\n    return count;\n  }\n\n  private appendPairsForProxy(proxy: number): void {\n    const leaf = this.proxyNodes[proxy]!;\n    const minX = this.nodeMinX[leaf]!;\n    const minY = this.nodeMinY[leaf]!;\n    const maxX = this.nodeMaxX[leaf]!;\n    const maxY = this.nodeMaxY[leaf]!;\n    let stackCount = 0;\n    this.ensureQueryStackCapacity(1);\n    this.queryStack[stackCount] = this.rootNode;\n    stackCount += 1;\n    while (stackCount > 0) {\n      stackCount -= 1;\n      const node = this.queryStack[stackCount]!;\n      if (!this.overlaps(node, minX, minY, maxX, maxY)) continue;\n      const other = this.nodeProxyIndices[node]!;\n      if (other !== NO_INDEX) {\n        if (other !== proxy) this.appendPair(proxy, other);\n        continue;\n      }\n      this.ensureQueryStackCapacity(stackCount + 2);\n      this.queryStack[stackCount] = this.nodeChild1[node]!;\n      this.queryStack[stackCount + 1] = this.nodeChild2[node]!;\n      stackCount += 2;\n    }\n  }\n\n  private appendPair(firstProxy: number, secondProxy: number): void {\n    let firstIndex = this.proxyColliderIndices[firstProxy]!;\n    let firstGeneration = this.proxyColliderGenerations[firstProxy]!;\n    let secondIndex = this.proxyColliderIndices[secondProxy]!;\n    let secondGeneration = this.proxyColliderGenerations[secondProxy]!;\n    const order = compareIdentity(\n      firstIndex,\n      firstGeneration,\n      secondIndex,\n      secondGeneration,\n    );\n    if (order === 0) return;\n    if (order > 0) {\n      const swapIndex = firstIndex;\n      const swapGeneration = firstGeneration;\n      firstIndex = secondIndex;\n      firstGeneration = secondGeneration;\n      secondIndex = swapIndex;\n      secondGeneration = swapGeneration;\n    }\n    this.ensurePairCapacity(this.pairCount + 1);\n    this.pairFirstColliderIndices[this.pairCount] = firstIndex;\n    this.pairFirstColliderGenerations[this.pairCount] = firstGeneration;\n    this.pairSecondColliderIndices[this.pairCount] = secondIndex;\n    this.pairSecondColliderGenerations[this.pairCount] = secondGeneration;\n    this.pairCount += 1;\n  }\n\n  private sortPairs(): void {\n    for (let root = Math.floor(this.pairCount / 2) - 1; root >= 0; root -= 1) {\n      this.siftPairDown(root, this.pairCount);\n    }\n    for (let end = this.pairCount - 1; end > 0; end -= 1) {\n      this.swapPairs(0, end);\n      this.siftPairDown(0, end);\n    }\n  }\n\n  private siftPairDown(root: number, count: number): void {\n    let current = root;\n    while (current * 2 + 1 < count) {\n      const left = current * 2 + 1;\n      const right = left + 1;\n      let greater = left;\n      if (right < count && this.comparePairs(left, right) < 0) greater = right;\n      if (this.comparePairs(current, greater) >= 0) return;\n      this.swapPairs(current, greater);\n      current = greater;\n    }\n  }\n\n  private comparePairs(first: number, second: number): number {\n    let comparison = compareIdentity(\n      this.pairFirstColliderIndices[first]!,\n      this.pairFirstColliderGenerations[first]!,\n      this.pairFirstColliderIndices[second]!,\n      this.pairFirstColliderGenerations[second]!,\n    );\n    if (comparison !== 0) return comparison;\n    comparison = compareIdentity(\n      this.pairSecondColliderIndices[first]!,\n      this.pairSecondColliderGenerations[first]!,\n      this.pairSecondColliderIndices[second]!,\n      this.pairSecondColliderGenerations[second]!,\n    );\n    return comparison;\n  }\n\n  private swapPairs(first: number, second: number): void {\n    let value = this.pairFirstColliderIndices[first]!;\n    this.pairFirstColliderIndices[first] =\n      this.pairFirstColliderIndices[second]!;\n    this.pairFirstColliderIndices[second] = value;\n    value = this.pairFirstColliderGenerations[first]!;\n    this.pairFirstColliderGenerations[first] =\n      this.pairFirstColliderGenerations[second]!;\n    this.pairFirstColliderGenerations[second] = value;\n    value = this.pairSecondColliderIndices[first]!;\n    this.pairSecondColliderIndices[first] =\n      this.pairSecondColliderIndices[second]!;\n    this.pairSecondColliderIndices[second] = value;\n    value = this.pairSecondColliderGenerations[first]!;\n    this.pairSecondColliderGenerations[first] =\n      this.pairSecondColliderGenerations[second]!;\n    this.pairSecondColliderGenerations[second] = value;\n  }\n\n  private deduplicatePairs(): void {\n    if (this.pairCount < 2) return;\n    let write = 1;\n    for (let read = 1; read < this.pairCount; read += 1) {\n      if (this.comparePairs(read, write - 1) === 0) continue;\n      if (write !== read) this.copyPair(read, write);\n      write += 1;\n    }\n    this.pairCount = write;\n  }\n\n  private copyPair(source: number, target: number): void {\n    this.pairFirstColliderIndices[target] =\n      this.pairFirstColliderIndices[source]!;\n    this.pairFirstColliderGenerations[target] =\n      this.pairFirstColliderGenerations[source]!;\n    this.pairSecondColliderIndices[target] =\n      this.pairSecondColliderIndices[source]!;\n    this.pairSecondColliderGenerations[target] =\n      this.pairSecondColliderGenerations[source]!;\n  }\n\n  private insertLeaf(leaf: number): void {\n    if (this.rootNode === NO_INDEX) {\n      this.rootNode = leaf;\n      this.nodeParents[leaf] = NO_INDEX;\n      return;\n    }\n    let sibling = this.rootNode;\n    while (this.nodeProxyIndices[sibling] === NO_INDEX) {\n      const first = this.nodeChild1[sibling]!;\n      const second = this.nodeChild2[sibling]!;\n      const perimeter = this.perimeter(sibling);\n      const combinedPerimeter = this.combinedPerimeter(sibling, leaf);\n      const parentCost = 2 * combinedPerimeter;\n      const inheritanceCost = 2 * (combinedPerimeter - perimeter);\n      const firstCost = this.descendCost(first, leaf, inheritanceCost);\n      const secondCost = this.descendCost(second, leaf, inheritanceCost);\n      if (parentCost < firstCost && parentCost < secondCost) break;\n      if (firstCost < secondCost) {\n        sibling = first;\n      } else if (secondCost < firstCost) {\n        sibling = second;\n      } else {\n        sibling =\n          this.nodeMinProxyIndices[first]! <= this.nodeMinProxyIndices[second]!\n            ? first\n            : second;\n      }\n    }\n\n    const oldParent = this.nodeParents[sibling]!;\n    const newParent = this.allocateNode();\n    this.nodeParents[newParent] = oldParent;\n    this.nodeChild1[newParent] = sibling;\n    this.nodeChild2[newParent] = leaf;\n    this.nodeProxyIndices[newParent] = NO_INDEX;\n    this.nodeParents[sibling] = newParent;\n    this.nodeParents[leaf] = newParent;\n    this.updateNode(newParent);\n    if (oldParent === NO_INDEX) {\n      this.rootNode = newParent;\n    } else if (this.nodeChild1[oldParent] === sibling) {\n      this.nodeChild1[oldParent] = newParent;\n    } else {\n      this.nodeChild2[oldParent] = newParent;\n    }\n\n    let node = this.nodeParents[leaf]!;\n    while (node !== NO_INDEX) {\n      node = this.balance(node);\n      this.updateNode(node);\n      node = this.nodeParents[node]!;\n    }\n  }\n\n  private removeLeaf(leaf: number): void {\n    if (leaf === this.rootNode) {\n      this.rootNode = NO_INDEX;\n      this.nodeParents[leaf] = NO_INDEX;\n      return;\n    }\n    const parent = this.nodeParents[leaf]!;\n    const grandParent = this.nodeParents[parent]!;\n    const sibling =\n      this.nodeChild1[parent] === leaf\n        ? this.nodeChild2[parent]!\n        : this.nodeChild1[parent]!;\n    if (grandParent === NO_INDEX) {\n      this.rootNode = sibling;\n      this.nodeParents[sibling] = NO_INDEX;\n      this.releaseNode(parent);\n    } else {\n      if (this.nodeChild1[grandParent] === parent) {\n        this.nodeChild1[grandParent] = sibling;\n      } else {\n        this.nodeChild2[grandParent] = sibling;\n      }\n      this.nodeParents[sibling] = grandParent;\n      this.releaseNode(parent);\n      let node = grandParent;\n      while (node !== NO_INDEX) {\n        node = this.balance(node);\n        this.updateNode(node);\n        node = this.nodeParents[node]!;\n      }\n    }\n    this.nodeParents[leaf] = NO_INDEX;\n  }\n\n  private balance(node: number): number {\n    if (\n      this.nodeProxyIndices[node] !== NO_INDEX ||\n      this.nodeHeights[node]! < 2\n    ) {\n      return node;\n    }\n    const first = this.nodeChild1[node]!;\n    const second = this.nodeChild2[node]!;\n    const balance = this.nodeHeights[second]! - this.nodeHeights[first]!;\n    if (balance > 1) return this.rotateSecondUp(node, second);\n    if (balance < -1) return this.rotateFirstUp(node, first);\n    return node;\n  }\n\n  private rotateSecondUp(node: number, second: number): number {\n    const secondFirst = this.nodeChild1[second]!;\n    const secondSecond = this.nodeChild2[second]!;\n    const parent = this.nodeParents[node]!;\n    this.nodeParents[second] = parent;\n    this.nodeChild1[second] = node;\n    this.nodeParents[node] = second;\n    this.replaceParentChild(parent, node, second);\n    const preferred = this.preferredBalanceChild(secondFirst, secondSecond);\n    const other = preferred === secondFirst ? secondSecond : secondFirst;\n    this.nodeChild2[second] = preferred;\n    this.nodeParents[preferred] = second;\n    this.nodeChild2[node] = other;\n    this.nodeParents[other] = node;\n    this.updateNode(node);\n    this.updateNode(second);\n    return second;\n  }\n\n  private rotateFirstUp(node: number, first: number): number {\n    const firstFirst = this.nodeChild1[first]!;\n    const firstSecond = this.nodeChild2[first]!;\n    const parent = this.nodeParents[node]!;\n    this.nodeParents[first] = parent;\n    this.nodeChild2[first] = node;\n    this.nodeParents[node] = first;\n    this.replaceParentChild(parent, node, first);\n    const preferred = this.preferredBalanceChild(firstFirst, firstSecond);\n    const other = preferred === firstFirst ? firstSecond : firstFirst;\n    this.nodeChild1[first] = preferred;\n    this.nodeParents[preferred] = first;\n    this.nodeChild1[node] = other;\n    this.nodeParents[other] = node;\n    this.updateNode(node);\n    this.updateNode(first);\n    return first;\n  }\n\n  private replaceParentChild(\n    parent: number,\n    previous: number,\n    replacement: number,\n  ): void {\n    if (parent === NO_INDEX) {\n      this.rootNode = replacement;\n    } else if (this.nodeChild1[parent] === previous) {\n      this.nodeChild1[parent] = replacement;\n    } else {\n      this.nodeChild2[parent] = replacement;\n    }\n  }\n\n  private preferredBalanceChild(first: number, second: number): number {\n    const firstHeight = this.nodeHeights[first]!;\n    const secondHeight = this.nodeHeights[second]!;\n    if (firstHeight > secondHeight) return first;\n    if (secondHeight > firstHeight) return second;\n    return this.nodeMinProxyIndices[first]! <= this.nodeMinProxyIndices[second]!\n      ? first\n      : second;\n  }\n\n  private descendCost(\n    node: number,\n    leaf: number,\n    inheritanceCost: number,\n  ): number {\n    const combinedPerimeter = this.combinedPerimeter(node, leaf);\n    return this.nodeProxyIndices[node] !== NO_INDEX\n      ? combinedPerimeter + inheritanceCost\n      : combinedPerimeter - this.perimeter(node) + inheritanceCost;\n  }\n\n  private updateNode(node: number): void {\n    const first = this.nodeChild1[node]!;\n    const second = this.nodeChild2[node]!;\n    this.nodeMinX[node] = Math.min(\n      this.nodeMinX[first]!,\n      this.nodeMinX[second]!,\n    );\n    this.nodeMinY[node] = Math.min(\n      this.nodeMinY[first]!,\n      this.nodeMinY[second]!,\n    );\n    this.nodeMaxX[node] = Math.max(\n      this.nodeMaxX[first]!,\n      this.nodeMaxX[second]!,\n    );\n    this.nodeMaxY[node] = Math.max(\n      this.nodeMaxY[first]!,\n      this.nodeMaxY[second]!,\n    );\n    this.nodeHeights[node] =\n      1 + Math.max(this.nodeHeights[first]!, this.nodeHeights[second]!);\n    this.nodeMinProxyIndices[node] = Math.min(\n      this.nodeMinProxyIndices[first]!,\n      this.nodeMinProxyIndices[second]!,\n    );\n  }\n\n  private setFatBounds(\n    node: number,\n    minX: number,\n    minY: number,\n    maxX: number,\n    maxY: number,\n    displacementX: number,\n    displacementY: number,\n  ): void {\n    this.nodeMinX[node] = minX - FAT_AABB_MARGIN + Math.min(0, displacementX);\n    this.nodeMinY[node] = minY - FAT_AABB_MARGIN + Math.min(0, displacementY);\n    this.nodeMaxX[node] = maxX + FAT_AABB_MARGIN + Math.max(0, displacementX);\n    this.nodeMaxY[node] = maxY + FAT_AABB_MARGIN + Math.max(0, displacementY);\n  }\n\n  private overlaps(\n    node: number,\n    minX: number,\n    minY: number,\n    maxX: number,\n    maxY: number,\n  ): boolean {\n    return !(\n      this.nodeMaxX[node]! < minX ||\n      this.nodeMaxY[node]! < minY ||\n      this.nodeMinX[node]! > maxX ||\n      this.nodeMinY[node]! > maxY\n    );\n  }\n\n  private perimeter(node: number): number {\n    return (\n      2 *\n      (this.nodeMaxX[node]! -\n        this.nodeMinX[node]! +\n        this.nodeMaxY[node]! -\n        this.nodeMinY[node]!)\n    );\n  }\n\n  private combinedPerimeter(first: number, second: number): number {\n    return (\n      2 *\n      (Math.max(this.nodeMaxX[first]!, this.nodeMaxX[second]!) -\n        Math.min(this.nodeMinX[first]!, this.nodeMinX[second]!) +\n        Math.max(this.nodeMaxY[first]!, this.nodeMaxY[second]!) -\n        Math.min(this.nodeMinY[first]!, this.nodeMinY[second]!))\n    );\n  }\n\n  private allocateNode(): number {\n    if (this.nodeFreeHead === NO_INDEX) this.growNodes();\n    const node = this.nodeFreeHead;\n    this.nodeFreeHead = this.nodeNextFree[node]!;\n    this.nodeNextFree[node] = NO_INDEX;\n    this.nodeActive[node] = 1;\n    this.nodeGenerations[node] = nextGeneration(this.nodeGenerations[node]!);\n    this.nodeParents[node] = NO_INDEX;\n    this.nodeChild1[node] = NO_INDEX;\n    this.nodeChild2[node] = NO_INDEX;\n    this.nodeHeights[node] = 0;\n    this.nodeProxyIndices[node] = NO_INDEX;\n    this.nodeMinProxyIndices[node] = MAX_PROXY_INDEX;\n    this.counters.treeNodeAllocations += 1;\n    this.counters.liveTreeNodes += 1;\n    this.counters.freeTreeNodeSlots -= 1;\n    return node;\n  }\n\n  private releaseNode(node: number): void {\n    this.nodeActive[node] = 0;\n    this.nodeParents[node] = NO_INDEX;\n    this.nodeChild1[node] = NO_INDEX;\n    this.nodeChild2[node] = NO_INDEX;\n    this.nodeHeights[node] = FREE_HEIGHT;\n    this.nodeProxyIndices[node] = NO_INDEX;\n    this.nodeMinProxyIndices[node] = MAX_PROXY_INDEX;\n    this.nodeMinX[node] = 0;\n    this.nodeMinY[node] = 0;\n    this.nodeMaxX[node] = 0;\n    this.nodeMaxY[node] = 0;\n    this.counters.treeNodeReleases += 1;\n    this.counters.liveTreeNodes -= 1;\n    if (this.nodeGenerations[node] === MAX_GENERATION) {\n      this.nodeNextFree[node] = NO_INDEX;\n      this.counters.retiredTreeNodeSlots += 1;\n    } else {\n      this.nodeNextFree[node] = this.nodeFreeHead;\n      this.nodeFreeHead = node;\n      this.counters.freeTreeNodeSlots += 1;\n    }\n  }\n\n  private bufferMove(proxy: number): void {\n    if (this.proxyMoved[proxy] === 1) return;\n    this.ensureMovedCapacity(this.movedCount + 1);\n    this.movedBuffer[this.movedCount] = proxy;\n    this.movedCount += 1;\n    this.proxyMoved[proxy] = 1;\n    this.counters.movedProxies = this.movedCount;\n  }\n\n  private unbufferMove(proxy: number): void {\n    for (let index = 0; index < this.movedCount; index += 1) {\n      if (this.movedBuffer[index] !== proxy) continue;\n      for (let shift = index + 1; shift < this.movedCount; shift += 1) {\n        this.movedBuffer[shift - 1] = this.movedBuffer[shift]!;\n      }\n      this.movedCount -= 1;\n      break;\n    }\n    this.proxyMoved[proxy] = 0;\n    this.counters.movedProxies = this.movedCount;\n  }\n\n  private growProxies(): void {\n    const oldCapacity = this.proxyCapacity;\n    const capacity = oldCapacity * 2;\n    this.proxyColliderIndices = growInt32(\n      this.proxyColliderIndices,\n      capacity,\n      NO_INDEX,\n    );\n    this.proxyColliderGenerations = growUint32(\n      this.proxyColliderGenerations,\n      capacity,\n    );\n    this.proxyNodes = growInt32(this.proxyNodes, capacity, NO_INDEX);\n    this.proxyGenerations = growUint32(this.proxyGenerations, capacity);\n    this.proxyMoved = growUint8(this.proxyMoved, capacity);\n    this.proxyActive = growUint8(this.proxyActive, capacity);\n    this.proxyNextFree = growFreeList(\n      this.proxyNextFree,\n      capacity,\n      oldCapacity,\n    );\n    this.proxyFreeHead = oldCapacity;\n    this.counters.proxyCapacity = capacity;\n    this.counters.proxyCapacityGrowths += 1;\n    this.counters.freeProxySlots += capacity - oldCapacity;\n  }\n\n  private growNodes(): void {\n    const oldCapacity = this.nodeCapacity;\n    const capacity = oldCapacity * 2;\n    this.nodeParents = growInt32(this.nodeParents, capacity, NO_INDEX);\n    this.nodeChild1 = growInt32(this.nodeChild1, capacity, NO_INDEX);\n    this.nodeChild2 = growInt32(this.nodeChild2, capacity, NO_INDEX);\n    this.nodeHeights = growInt32(this.nodeHeights, capacity, FREE_HEIGHT);\n    this.nodeProxyIndices = growInt32(\n      this.nodeProxyIndices,\n      capacity,\n      NO_INDEX,\n    );\n    this.nodeMinProxyIndices = growInt32(\n      this.nodeMinProxyIndices,\n      capacity,\n      MAX_PROXY_INDEX,\n    );\n    this.nodeMinX = growFloat64(this.nodeMinX, capacity);\n    this.nodeMinY = growFloat64(this.nodeMinY, capacity);\n    this.nodeMaxX = growFloat64(this.nodeMaxX, capacity);\n    this.nodeMaxY = growFloat64(this.nodeMaxY, capacity);\n    this.nodeGenerations = growUint32(this.nodeGenerations, capacity);\n    this.nodeActive = growUint8(this.nodeActive, capacity);\n    this.nodeNextFree = growFreeList(this.nodeNextFree, capacity, oldCapacity);\n    this.nodeFreeHead = oldCapacity;\n    this.counters.treeNodeCapacity = capacity;\n    this.counters.treeNodeCapacityGrowths += 1;\n    this.counters.freeTreeNodeSlots += capacity - oldCapacity;\n  }\n\n  private ensureMovedCapacity(required: number): void {\n    if (required <= this.movedBuffer.length) return;\n    let capacity = this.movedBuffer.length * 2;\n    while (capacity < required) capacity *= 2;\n    const moved = new Int32Array(capacity);\n    moved.set(this.movedBuffer);\n    this.movedBuffer = moved;\n    this.counters.movedBufferCapacity = capacity;\n    this.counters.movedBufferGrowths += 1;\n  }\n\n  private ensureColliderProxyCapacity(required: number): void {\n    if (required <= this.colliderProxyIndices.length) return;\n    let capacity = this.colliderProxyIndices.length * 2;\n    while (capacity < required) capacity *= 2;\n    this.colliderProxyIndices = growInt32(\n      this.colliderProxyIndices,\n      capacity,\n      NO_INDEX,\n    );\n    this.counters.colliderProxyMapCapacity = capacity;\n    this.counters.colliderProxyMapGrowths += 1;\n  }\n\n  private ensurePairCapacity(required: number): void {\n    if (required <= this.pairFirstColliderIndices.length) return;\n    let capacity = this.pairFirstColliderIndices.length * 2;\n    while (capacity < required) capacity *= 2;\n    this.pairFirstColliderIndices = growInt32(\n      this.pairFirstColliderIndices,\n      capacity,\n      0,\n    );\n    this.pairFirstColliderGenerations = growUint32(\n      this.pairFirstColliderGenerations,\n      capacity,\n    );\n    this.pairSecondColliderIndices = growInt32(\n      this.pairSecondColliderIndices,\n      capacity,\n      0,\n    );\n    this.pairSecondColliderGenerations = growUint32(\n      this.pairSecondColliderGenerations,\n      capacity,\n    );\n    this.counters.pairBufferCapacity = capacity;\n    this.counters.pairBufferGrowths += 1;\n  }\n\n  private ensureQueryStackCapacity(required: number): void {\n    if (required <= this.queryStack.length) return;\n    let capacity = this.queryStack.length * 2;\n    while (capacity < required) capacity *= 2;\n    const stack = new Int32Array(capacity);\n    stack.set(this.queryStack);\n    this.queryStack = stack;\n    this.counters.queryStackCapacity = capacity;\n    this.counters.queryStackGrowths += 1;\n  }\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 nextGeneration(generation: number): number {\n  return generation + 1;\n}\n\nfunction compareIdentity(\n  firstIndex: number,\n  firstGeneration: number,\n  secondIndex: number,\n  secondGeneration: number,\n): number {\n  if (firstIndex !== secondIndex) return firstIndex < secondIndex ? -1 : 1;\n  if (firstGeneration === secondGeneration) return 0;\n  return firstGeneration < secondGeneration ? -1 : 1;\n}\n\nfunction sortInt32Range(\n  values: Int32Array,\n  offset: number,\n  count: number,\n): void {\n  for (let index = 1; index < count; index += 1) {\n    const value = values[offset + index]!;\n    let position = index;\n    while (position > 0 && values[offset + position - 1]! > value) {\n      values[offset + position] = values[offset + position - 1]!;\n      position -= 1;\n    }\n    values[offset + position] = value;\n  }\n}\n\nfunction createFreeList(capacity: number, start: number): Int32Array {\n  const result = filledInt32(capacity, NO_INDEX);\n  for (let index = start; index + 1 < capacity; index += 1) {\n    result[index] = index + 1;\n  }\n  return result;\n}\n\nfunction growFreeList(\n  source: Int32Array,\n  capacity: number,\n  start: number,\n): Int32Array {\n  const result = createFreeList(capacity, start);\n  result.set(source);\n  return result;\n}\n\nfunction filledInt32(capacity: number, value: number): Int32Array {\n  const result = new Int32Array(capacity);\n  result.fill(value);\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\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 growInt32(\n  source: Int32Array,\n  capacity: number,\n  fill: number,\n): Int32Array {\n  const result = filledInt32(capacity, fill);\n  result.set(source);\n  return result;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,19 @@
+import { DynamicAabbBroadPhase2D } from "./broad-phase.js";
+import type { BodyStore2D, ColliderStore2D } from "./storage.js";
+export declare const BODY_CCD_2D: number;
+export declare class BoundedCcd2D {
+    impactCount: number;
+    capCount: number;
+    impactColliderIndices: Int32Array;
+    private candidateProxies;
+    private readonly shapeShells;
+    constructor(initialCapacity?: number);
+    resolveCandidateBodies(bodies: BodyStore2D, colliders: ColliderStore2D, broadPhase: DynamicAabbBroadPhase2D, bodyIndices: Int32Array, bodyCount: number, previousPositionX: Float64Array, previousPositionY: Float64Array, previousRotationRadians: Float64Array): void;
+    private resolveBody;
+    private findEarliestImpact;
+    private isEligibleBody;
+    private shapeShell;
+    private ensureCandidateCapacity;
+    private ensureImpactCapacity;
+}
+export declare function collisionFiltersAllow2D(first: unknown, second: unknown): boolean;

package/dist/features/physics/lib/2d/world/ccd.js

@@ -0,0 +1,265 @@
+import {
+  boundsOfShape2D,
+  shapeCastAgainstShape2D
+} from "../../../2d-geometry.js";
+import { createShape2D } from "../shape-records.js";
+import { MAX_CCD_IMPACTS_PER_TICK, RADIANS_TO_DEGREES } from "../numeric-policy.js";
+import { COLLIDER_SENSOR_2D } from "./contact-cache.js";
+import { BODY_TYPE_DYNAMIC_2D } from "./integrator.js";
+import { BODY_SLEEPING_2D } from "./solver.js";
+const BODY_CCD_2D = 1 << 5;
+class BoundedCcd2D {
+  impactCount = 0;
+  capCount = 0;
+  impactColliderIndices;
+  candidateProxies;
+  shapeShells = /* @__PURE__ */ new WeakMap();
+  constructor(initialCapacity = 4) {
+    const capacity = normalizedCapacity(initialCapacity);
+    this.candidateProxies = new Int32Array(capacity);
+    this.impactColliderIndices = new Int32Array(capacity);
+  }
+  resolveCandidateBodies(bodies, colliders, broadPhase, bodyIndices, bodyCount, previousPositionX, previousPositionY, previousRotationRadians) {
+    this.impactCount = 0;
+    this.capCount = 0;
+    this.ensureCandidateCapacity(broadPhase.proxyCapacity);
+    this.ensureImpactCapacity(Math.max(1, bodyCount * MAX_CCD_IMPACTS_PER_TICK));
+    for (let offset = 0; offset < bodyCount; offset += 1) {
+      const body = bodyIndices[offset];
+      if (!this.isEligibleBody(bodies, body)) continue;
+      this.resolveBody(
+        bodies,
+        colliders,
+        broadPhase,
+        body,
+        previousPositionX[body],
+        previousPositionY[body],
+        previousRotationRadians[body]
+      );
+    }
+  }
+  resolveBody(bodies, colliders, broadPhase, body, fromX, fromY, fromRotation) {
+    let currentX = fromX;
+    let currentY = fromY;
+    let remainingX = bodies.positionX[body] - fromX;
+    let remainingY = bodies.positionY[body] - fromY;
+    let impacts = 0;
+    while ((remainingX !== 0 || remainingY !== 0) && impacts < MAX_CCD_IMPACTS_PER_TICK) {
+      const selected = this.findEarliestImpact(
+        bodies,
+        colliders,
+        broadPhase,
+        body,
+        currentX,
+        currentY,
+        fromRotation,
+        remainingX,
+        remainingY
+      );
+      if (selected === null) {
+        currentX += remainingX;
+        currentY += remainingY;
+        remainingX = 0;
+        remainingY = 0;
+        break;
+      }
+      currentX += remainingX * selected.timeOfImpact;
+      currentY += remainingY * selected.timeOfImpact;
+      const fraction = 1 - selected.timeOfImpact;
+      remainingX *= fraction;
+      remainingY *= fraction;
+      const restitution = Math.max(
+        materialRestitution(colliders.materials[selected.movingCollider]),
+        materialRestitution(colliders.materials[selected.targetCollider])
+      );
+      const remainingNormal = remainingX * selected.normalX + remainingY * selected.normalY;
+      if (remainingNormal < 0) {
+        remainingX -= (1 + restitution) * remainingNormal * selected.normalX;
+        remainingY -= (1 + restitution) * remainingNormal * selected.normalY;
+      }
+      const velocityNormal = bodies.linearVelocityX[body] * selected.normalX + bodies.linearVelocityY[body] * selected.normalY;
+      if (velocityNormal < 0) {
+        bodies.linearVelocityX[body] -= (1 + restitution) * velocityNormal * selected.normalX;
+        bodies.linearVelocityY[body] -= (1 + restitution) * velocityNormal * selected.normalY;
+      }
+      this.impactColliderIndices[this.impactCount] = selected.targetCollider;
+      this.impactCount += 1;
+      impacts += 1;
+    }
+    if (remainingX !== 0 || remainingY !== 0) {
+      currentX += remainingX;
+      currentY += remainingY;
+      if (impacts === MAX_CCD_IMPACTS_PER_TICK) this.capCount += 1;
+    }
+    bodies.positionX[body] = currentX;
+    bodies.positionY[body] = currentY;
+  }
+  findEarliestImpact(bodies, colliders, broadPhase, body, fromX, fromY, rotationRadians, translationX, translationY) {
+    let selected = null;
+    for (let movingCollider = 0; movingCollider < colliders.capacity; movingCollider += 1) {
+      const movingGeneration = colliders.generations[movingCollider];
+      if (!colliders.has(movingCollider, movingGeneration)) continue;
+      if (colliders.bodyIndices[movingCollider] !== body) continue;
+      if ((colliders.flags[movingCollider] & COLLIDER_SENSOR_2D) !== 0) continue;
+      const movingRecord = colliders.shapes[movingCollider];
+      if (movingRecord === null || !isSupportedSolid(movingRecord)) continue;
+      const movingShape = this.shapeShell(movingRecord);
+      const fromPose = publicPoseFromCenter(
+        bodies,
+        body,
+        fromX,
+        fromY,
+        rotationRadians
+      );
+      const start = boundsOfShape2D(movingShape, fromPose);
+      const end = boundsOfShape2D(
+        movingShape,
+        publicPoseFromCenter(
+          bodies,
+          body,
+          fromX + translationX,
+          fromY + translationY,
+          rotationRadians
+        )
+      );
+      const candidateCount = broadPhase.queryAabbInto(
+        Math.min(start.min[0], end.min[0]),
+        Math.min(start.min[1], end.min[1]),
+        Math.max(start.max[0], end.max[0]),
+        Math.max(start.max[1], end.max[1]),
+        this.candidateProxies,
+        0,
+        this.candidateProxies.length
+      );
+      for (let candidate = 0; candidate < candidateCount; candidate += 1) {
+        const proxy = this.candidateProxies[candidate];
+        const targetCollider = broadPhase.proxyColliderIndices[proxy];
+        const targetGeneration = broadPhase.proxyColliderGenerations[proxy];
+        if (!colliders.has(targetCollider, targetGeneration)) continue;
+        if (targetCollider === movingCollider) continue;
+        const targetBody = colliders.bodyIndices[targetCollider];
+        if (targetBody === body) continue;
+        if ((colliders.flags[targetCollider] & COLLIDER_SENSOR_2D) !== 0) continue;
+        if (!collisionFiltersAllow2D(colliders.filters[movingCollider], colliders.filters[targetCollider])) continue;
+        const targetRecord = colliders.shapes[targetCollider];
+        if (targetRecord === null || !isSupportedSolid(targetRecord)) continue;
+        const hit = shapeCastAgainstShape2D(
+          movingShape,
+          fromPose,
+          [translationX, translationY],
+          this.shapeShell(targetRecord),
+          publicPoseFromCenter(
+            bodies,
+            targetBody,
+            bodies.positionX[targetBody],
+            bodies.positionY[targetBody],
+            bodies.rotationRadians[targetBody]
+          )
+        );
+        if (hit === null) continue;
+        if (selected === null || hit.timeOfImpact < selected.timeOfImpact || hit.timeOfImpact === selected.timeOfImpact && compareColliderIdentity(
+          targetCollider,
+          targetGeneration,
+          selected.targetCollider,
+          colliders.generations[selected.targetCollider]
+        ) < 0) {
+          selected = {
+            movingCollider,
+            targetCollider,
+            timeOfImpact: hit.timeOfImpact,
+            normalX: hit.normal[0],
+            normalY: hit.normal[1]
+          };
+        }
+      }
+    }
+    return selected;
+  }
+  isEligibleBody(bodies, body) {
+    return body >= 0 && body < bodies.capacity && (bodies.flags[body] & BODY_TYPE_DYNAMIC_2D) !== 0 && (bodies.flags[body] & BODY_CCD_2D) !== 0 && (bodies.flags[body] & BODY_SLEEPING_2D) === 0 && bodies.inverseMass[body] > 0;
+  }
+  shapeShell(record) {
+    let shell = this.shapeShells.get(record);
+    if (shell === void 0) {
+      shell = createShape2D(record);
+      this.shapeShells.set(record, shell);
+    }
+    return shell;
+  }
+  ensureCandidateCapacity(required) {
+    if (required <= this.candidateProxies.length) return;
+    this.candidateProxies = growInt32(this.candidateProxies, normalizedCapacity(required));
+  }
+  ensureImpactCapacity(required) {
+    if (required <= this.impactColliderIndices.length) return;
+    this.impactColliderIndices = growInt32(this.impactColliderIndices, normalizedCapacity(required));
+  }
+}
+function collisionFiltersAllow2D(first, second) {
+  const firstFilter = asFilter(first);
+  const secondFilter = asFilter(second);
+  const firstGroup = integerBits(firstFilter.group ?? 0);
+  const secondGroup = integerBits(secondFilter.group ?? 0);
+  if (firstGroup !== 0 && firstGroup === secondGroup) return firstGroup > 0;
+  const firstCategory = unsignedBits(firstFilter.category ?? 1);
+  const secondCategory = unsignedBits(secondFilter.category ?? 1);
+  const firstMask = unsignedBits(firstFilter.mask ?? 4294967295);
+  const secondMask = unsignedBits(secondFilter.mask ?? 4294967295);
+  return (firstMask & secondCategory) !== 0 && (secondMask & firstCategory) !== 0;
+}
+function isSupportedSolid(record) {
+  return record.leaves.length === 1 && record.leaves[0].kind !== "segment";
+}
+function publicPose(x, y, rotationRadians) {
+  return {
+    position: [x, y],
+    rotationDegrees: rotationRadians * RADIANS_TO_DEGREES
+  };
+}
+function publicPoseFromCenter(bodies, index, centerX, centerY, rotationRadians) {
+  const cosine = Math.cos(rotationRadians);
+  const sine = Math.sin(rotationRadians);
+  const localCenterX = bodies.localCenterX[index];
+  const localCenterY = bodies.localCenterY[index];
+  return publicPose(
+    centerX - cosine * localCenterX + sine * localCenterY,
+    centerY - sine * localCenterX - cosine * localCenterY,
+    rotationRadians
+  );
+}
+function materialRestitution(material) {
+  if (typeof material !== "object" || material === null) return 0;
+  const value = material.restitution;
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function asFilter(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function unsignedBits(value) {
+  return Number.isFinite(value) ? value >>> 0 : 0;
+}
+function integerBits(value) {
+  return Number.isFinite(value) ? value | 0 : 0;
+}
+function compareColliderIdentity(firstIndex, firstGeneration, secondIndex, secondGeneration) {
+  return firstIndex - secondIndex || firstGeneration - secondGeneration;
+}
+function normalizedCapacity(required) {
+  if (!Number.isInteger(required) || required < 1) {
+    throw new RangeError("capacity must be a positive integer.");
+  }
+  let capacity = 1;
+  while (capacity < required) capacity *= 2;
+  return capacity;
+}
+function growInt32(source, capacity) {
+  const result = new Int32Array(capacity);
+  result.set(source);
+  return result;
+}
+export {
+  BODY_CCD_2D,
+  BoundedCcd2D,
+  collisionFiltersAllow2D
+};
+//# sourceMappingURL=ccd.js.map

package/dist/features/physics/lib/2d/world/ccd.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/world/ccd.ts"],
+  "sourcesContent": ["import {\n  boundsOfShape2D,\n  shapeCastAgainstShape2D,\n  type PibblPhysicsPose2D,\n  type PibblPhysicsShape2D,\n} from \"../../../2d-geometry.js\";\nimport { createShape2D, type ShapeRecord2D } from \"../shape-records.js\";\nimport { MAX_CCD_IMPACTS_PER_TICK, RADIANS_TO_DEGREES } from \"../numeric-policy.js\";\nimport { DynamicAabbBroadPhase2D } from \"./broad-phase.js\";\nimport { COLLIDER_SENSOR_2D } from \"./contact-cache.js\";\nimport { BODY_TYPE_DYNAMIC_2D } from \"./integrator.js\";\nimport { BODY_SLEEPING_2D } from \"./solver.js\";\nimport type { BodyStore2D, ColliderStore2D } from \"./storage.js\";\n\nexport const BODY_CCD_2D = 1 << 5;\n\ninterface SelectedImpact2D {\n  readonly movingCollider: number;\n  readonly targetCollider: number;\n  readonly timeOfImpact: number;\n  readonly normalX: number;\n  readonly normalY: number;\n}\n\ninterface CollisionFilterRecord2D {\n  readonly category?: number;\n  readonly mask?: number;\n  readonly group?: number;\n}\n\nexport class BoundedCcd2D {\n  impactCount = 0;\n  capCount = 0;\n  impactColliderIndices: Int32Array;\n\n  private candidateProxies: Int32Array;\n  private readonly shapeShells = new WeakMap<ShapeRecord2D, PibblPhysicsShape2D>();\n\n  constructor(initialCapacity = 4) {\n    const capacity = normalizedCapacity(initialCapacity);\n    this.candidateProxies = new Int32Array(capacity);\n    this.impactColliderIndices = new Int32Array(capacity);\n  }\n\n  resolveCandidateBodies(\n    bodies: BodyStore2D,\n    colliders: ColliderStore2D,\n    broadPhase: DynamicAabbBroadPhase2D,\n    bodyIndices: Int32Array,\n    bodyCount: number,\n    previousPositionX: Float64Array,\n    previousPositionY: Float64Array,\n    previousRotationRadians: Float64Array,\n  ): void {\n    this.impactCount = 0;\n    this.capCount = 0;\n    this.ensureCandidateCapacity(broadPhase.proxyCapacity);\n    this.ensureImpactCapacity(Math.max(1, bodyCount * MAX_CCD_IMPACTS_PER_TICK));\n    for (let offset = 0; offset < bodyCount; offset += 1) {\n      const body = bodyIndices[offset]!;\n      if (!this.isEligibleBody(bodies, body)) continue;\n      this.resolveBody(\n        bodies,\n        colliders,\n        broadPhase,\n        body,\n        previousPositionX[body]!,\n        previousPositionY[body]!,\n        previousRotationRadians[body]!,\n      );\n    }\n  }\n\n  private resolveBody(\n    bodies: BodyStore2D,\n    colliders: ColliderStore2D,\n    broadPhase: DynamicAabbBroadPhase2D,\n    body: number,\n    fromX: number,\n    fromY: number,\n    fromRotation: number,\n  ): void {\n    let currentX = fromX;\n    let currentY = fromY;\n    let remainingX = bodies.positionX[body]! - fromX;\n    let remainingY = bodies.positionY[body]! - fromY;\n    let impacts = 0;\n    while ((remainingX !== 0 || remainingY !== 0) && impacts < MAX_CCD_IMPACTS_PER_TICK) {\n      const selected = this.findEarliestImpact(\n        bodies,\n        colliders,\n        broadPhase,\n        body,\n        currentX,\n        currentY,\n        fromRotation,\n        remainingX,\n        remainingY,\n      );\n      if (selected === null) {\n        currentX += remainingX;\n        currentY += remainingY;\n        remainingX = 0;\n        remainingY = 0;\n        break;\n      }\n      currentX += remainingX * selected.timeOfImpact;\n      currentY += remainingY * selected.timeOfImpact;\n      const fraction = 1 - selected.timeOfImpact;\n      remainingX *= fraction;\n      remainingY *= fraction;\n      const restitution = Math.max(\n        materialRestitution(colliders.materials[selected.movingCollider]),\n        materialRestitution(colliders.materials[selected.targetCollider]),\n      );\n      const remainingNormal = remainingX * selected.normalX + remainingY * selected.normalY;\n      if (remainingNormal < 0) {\n        remainingX -= (1 + restitution) * remainingNormal * selected.normalX;\n        remainingY -= (1 + restitution) * remainingNormal * selected.normalY;\n      }\n      const velocityNormal =\n        bodies.linearVelocityX[body]! * selected.normalX + bodies.linearVelocityY[body]! * selected.normalY;\n      if (velocityNormal < 0) {\n        bodies.linearVelocityX[body] -= (1 + restitution) * velocityNormal * selected.normalX;\n        bodies.linearVelocityY[body] -= (1 + restitution) * velocityNormal * selected.normalY;\n      }\n      this.impactColliderIndices[this.impactCount] = selected.targetCollider;\n      this.impactCount += 1;\n      impacts += 1;\n    }\n    if (remainingX !== 0 || remainingY !== 0) {\n      currentX += remainingX;\n      currentY += remainingY;\n      if (impacts === MAX_CCD_IMPACTS_PER_TICK) this.capCount += 1;\n    }\n    bodies.positionX[body] = currentX;\n    bodies.positionY[body] = currentY;\n  }\n\n  private findEarliestImpact(\n    bodies: BodyStore2D,\n    colliders: ColliderStore2D,\n    broadPhase: DynamicAabbBroadPhase2D,\n    body: number,\n    fromX: number,\n    fromY: number,\n    rotationRadians: number,\n    translationX: number,\n    translationY: number,\n  ): SelectedImpact2D | null {\n    let selected: SelectedImpact2D | null = null;\n    for (let movingCollider = 0; movingCollider < colliders.capacity; movingCollider += 1) {\n      const movingGeneration = colliders.generations[movingCollider]!;\n      if (!colliders.has(movingCollider, movingGeneration)) continue;\n      if (colliders.bodyIndices[movingCollider] !== body) continue;\n      if ((colliders.flags[movingCollider]! & COLLIDER_SENSOR_2D) !== 0) continue;\n      const movingRecord = colliders.shapes[movingCollider];\n      if (movingRecord === null || !isSupportedSolid(movingRecord)) continue;\n      const movingShape = this.shapeShell(movingRecord);\n      const fromPose = publicPoseFromCenter(\n        bodies,\n        body,\n        fromX,\n        fromY,\n        rotationRadians,\n      );\n      const start = boundsOfShape2D(movingShape, fromPose);\n      const end = boundsOfShape2D(\n        movingShape,\n        publicPoseFromCenter(\n          bodies,\n          body,\n          fromX + translationX,\n          fromY + translationY,\n          rotationRadians,\n        ),\n      );\n      const candidateCount = broadPhase.queryAabbInto(\n        Math.min(start.min[0], end.min[0]),\n        Math.min(start.min[1], end.min[1]),\n        Math.max(start.max[0], end.max[0]),\n        Math.max(start.max[1], end.max[1]),\n        this.candidateProxies,\n        0,\n        this.candidateProxies.length,\n      );\n      for (let candidate = 0; candidate < candidateCount; candidate += 1) {\n        const proxy = this.candidateProxies[candidate]!;\n        const targetCollider = broadPhase.proxyColliderIndices[proxy]!;\n        const targetGeneration = broadPhase.proxyColliderGenerations[proxy]!;\n        if (!colliders.has(targetCollider, targetGeneration)) continue;\n        if (targetCollider === movingCollider) continue;\n        const targetBody = colliders.bodyIndices[targetCollider]!;\n        if (targetBody === body) continue;\n        if ((colliders.flags[targetCollider]! & COLLIDER_SENSOR_2D) !== 0) continue;\n        if (!collisionFiltersAllow2D(colliders.filters[movingCollider], colliders.filters[targetCollider])) continue;\n        const targetRecord = colliders.shapes[targetCollider];\n        if (targetRecord === null || !isSupportedSolid(targetRecord)) continue;\n        const hit = shapeCastAgainstShape2D(\n          movingShape,\n          fromPose,\n          [translationX, translationY],\n          this.shapeShell(targetRecord),\n          publicPoseFromCenter(\n            bodies,\n            targetBody,\n            bodies.positionX[targetBody]!,\n            bodies.positionY[targetBody]!,\n            bodies.rotationRadians[targetBody]!,\n          ),\n        );\n        if (hit === null) continue;\n        if (\n          selected === null ||\n          hit.timeOfImpact < selected.timeOfImpact ||\n          (hit.timeOfImpact === selected.timeOfImpact &&\n            compareColliderIdentity(\n              targetCollider,\n              targetGeneration,\n              selected.targetCollider,\n              colliders.generations[selected.targetCollider]!,\n            ) < 0)\n        ) {\n          selected = {\n            movingCollider,\n            targetCollider,\n            timeOfImpact: hit.timeOfImpact,\n            normalX: hit.normal[0],\n            normalY: hit.normal[1],\n          };\n        }\n      }\n    }\n    return selected;\n  }\n\n  private isEligibleBody(bodies: BodyStore2D, body: number): boolean {\n    return (\n      body >= 0 &&\n      body < bodies.capacity &&\n      (bodies.flags[body]! & BODY_TYPE_DYNAMIC_2D) !== 0 &&\n      (bodies.flags[body]! & BODY_CCD_2D) !== 0 &&\n      (bodies.flags[body]! & BODY_SLEEPING_2D) === 0 &&\n      bodies.inverseMass[body]! > 0\n    );\n  }\n\n  private shapeShell(record: ShapeRecord2D): PibblPhysicsShape2D {\n    let shell = this.shapeShells.get(record);\n    if (shell === undefined) {\n      shell = createShape2D(record);\n      this.shapeShells.set(record, shell);\n    }\n    return shell;\n  }\n\n  private ensureCandidateCapacity(required: number): void {\n    if (required <= this.candidateProxies.length) return;\n    this.candidateProxies = growInt32(this.candidateProxies, normalizedCapacity(required));\n  }\n\n  private ensureImpactCapacity(required: number): void {\n    if (required <= this.impactColliderIndices.length) return;\n    this.impactColliderIndices = growInt32(this.impactColliderIndices, normalizedCapacity(required));\n  }\n}\n\nexport function collisionFiltersAllow2D(first: unknown, second: unknown): boolean {\n  const firstFilter = asFilter(first);\n  const secondFilter = asFilter(second);\n  const firstGroup = integerBits(firstFilter.group ?? 0);\n  const secondGroup = integerBits(secondFilter.group ?? 0);\n  if (firstGroup !== 0 && firstGroup === secondGroup) return firstGroup > 0;\n  const firstCategory = unsignedBits(firstFilter.category ?? 1);\n  const secondCategory = unsignedBits(secondFilter.category ?? 1);\n  const firstMask = unsignedBits(firstFilter.mask ?? 0xffff_ffff);\n  const secondMask = unsignedBits(secondFilter.mask ?? 0xffff_ffff);\n  return (firstMask & secondCategory) !== 0 && (secondMask & firstCategory) !== 0;\n}\n\nfunction isSupportedSolid(record: ShapeRecord2D): boolean {\n  return record.leaves.length === 1 && record.leaves[0]!.kind !== \"segment\";\n}\n\nfunction publicPose(x: number, y: number, rotationRadians: number): PibblPhysicsPose2D {\n  return {\n    position: [x, y],\n    rotationDegrees: rotationRadians * RADIANS_TO_DEGREES,\n  };\n}\n\nfunction publicPoseFromCenter(\n  bodies: BodyStore2D,\n  index: number,\n  centerX: number,\n  centerY: number,\n  rotationRadians: number,\n): PibblPhysicsPose2D {\n  const cosine = Math.cos(rotationRadians);\n  const sine = Math.sin(rotationRadians);\n  const localCenterX = bodies.localCenterX[index]!;\n  const localCenterY = bodies.localCenterY[index]!;\n  return publicPose(\n    centerX - cosine * localCenterX + sine * localCenterY,\n    centerY - sine * localCenterX - cosine * localCenterY,\n    rotationRadians,\n  );\n}\n\nfunction materialRestitution(material: unknown): number {\n  if (typeof material !== \"object\" || material === null) return 0;\n  const value = (material as Readonly<{ restitution?: unknown }>).restitution;\n  return typeof value === \"number\" && Number.isFinite(value) && value >= 0 ? value : 0;\n}\n\nfunction asFilter(value: unknown): CollisionFilterRecord2D {\n  return typeof value === \"object\" && value !== null ? (value as CollisionFilterRecord2D) : {};\n}\n\nfunction unsignedBits(value: number): number {\n  return Number.isFinite(value) ? value >>> 0 : 0;\n}\n\nfunction integerBits(value: number): number {\n  return Number.isFinite(value) ? value | 0 : 0;\n}\n\nfunction compareColliderIdentity(\n  firstIndex: number,\n  firstGeneration: number,\n  secondIndex: number,\n  secondGeneration: number,\n): number {\n  return firstIndex - secondIndex || firstGeneration - secondGeneration;\n}\n\nfunction normalizedCapacity(required: number): number {\n  if (!Number.isInteger(required) || required < 1) {\n    throw new RangeError(\"capacity must be a positive integer.\");\n  }\n  let capacity = 1;\n  while (capacity < required) 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"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,81 @@
+import type { PrivateManifold2D } from "../collision/manifold.js";
+import type { ColliderStore2D } from "./storage.js";
+export declare const COLLIDER_SENSOR_2D: number;
+export declare const CONTACT_EVENT_BEGIN_2D = 1;
+export declare const CONTACT_EVENT_END_2D = 2;
+export declare const OVERLAP_EVENT_BEGIN_2D = 3;
+export declare const OVERLAP_EVENT_END_2D = 4;
+export interface SortedColliderPairs2D {
+    readonly pairFirstColliderIndices: Int32Array;
+    readonly pairFirstColliderGenerations: Uint32Array;
+    readonly pairSecondColliderIndices: Int32Array;
+    readonly pairSecondColliderGenerations: Uint32Array;
+    readonly pairCount: number;
+}
+export type PrivateManifoldProvider2D = (firstColliderIndex: number, secondColliderIndex: number) => PrivateManifold2D | null;
+export declare class ContactCache2D {
+    contactCount: number;
+    firstColliderIndices: Int32Array;
+    firstColliderGenerations: Uint32Array;
+    secondColliderIndices: Int32Array;
+    secondColliderGenerations: Uint32Array;
+    firstBodyIndices: Int32Array;
+    firstBodyGenerations: Uint32Array;
+    secondBodyIndices: Int32Array;
+    secondBodyGenerations: Uint32Array;
+    sensorFlags: Uint8Array;
+    mixedFriction: Float64Array;
+    mixedRestitution: Float64Array;
+    normalX: Float64Array;
+    normalY: Float64Array;
+    firstLeafIndices: Int32Array;
+    secondLeafIndices: Int32Array;
+    pointCounts: Uint8Array;
+    pointFirstX: Float64Array;
+    pointFirstY: Float64Array;
+    pointSecondX: Float64Array;
+    pointSecondY: Float64Array;
+    pointSeparations: Float64Array;
+    pointFirstFeatures: Int32Array;
+    pointSecondFeatures: Int32Array;
+    pointNormalImpulses: Float64Array;
+    pointTangentImpulses: Float64Array;
+    stagingFirstColliderIndices: Int32Array;
+    stagingFirstColliderGenerations: Uint32Array;
+    stagingSecondColliderIndices: Int32Array;
+    stagingSecondColliderGenerations: Uint32Array;
+    stagingFirstBodyIndices: Int32Array;
+    stagingFirstBodyGenerations: Uint32Array;
+    stagingSecondBodyIndices: Int32Array;
+    stagingSecondBodyGenerations: Uint32Array;
+    stagingSensorFlags: Uint8Array;
+    stagingMixedFriction: Float64Array;
+    stagingMixedRestitution: Float64Array;
+    stagingNormalX: Float64Array;
+    stagingNormalY: Float64Array;
+    stagingFirstLeafIndices: Int32Array;
+    stagingSecondLeafIndices: Int32Array;
+    stagingPointCounts: Uint8Array;
+    stagingPointFirstX: Float64Array;
+    stagingPointFirstY: Float64Array;
+    stagingPointSecondX: Float64Array;
+    stagingPointSecondY: Float64Array;
+    stagingPointSeparations: Float64Array;
+    stagingPointFirstFeatures: Int32Array;
+    stagingPointSecondFeatures: Int32Array;
+    stagingPointNormalImpulses: Float64Array;
+    stagingPointTangentImpulses: Float64Array;
+    eventCount: number;
+    eventTypes: Uint8Array;
+    eventFirstColliderIndices: Int32Array;
+    eventFirstColliderGenerations: Uint32Array;
+    eventSecondColliderIndices: Int32Array;
+    eventSecondColliderGenerations: Uint32Array;
+    constructor(initialCapacity?: number);
+    ensureCapacity(required: number): void;
+    ensureEventCapacity(required: number): void;
+    swapGenerations(nextCount: number, nextEventCount: number): void;
+    writeStagingContact(target: number, firstColliderIndex: number, firstColliderGeneration: number, secondColliderIndex: number, secondColliderGeneration: number, colliders: ColliderStore2D, manifold: PrivateManifold2D, oldContact: number): void;
+    private findMatchingPoint;
+}
+export declare function updateSortedContactCache2D(cache: ContactCache2D, pairs: SortedColliderPairs2D, colliders: ColliderStore2D, manifoldProvider: PrivateManifoldProvider2D): void;