@codexo/exojs-physics 0.15.3 → 0.16.0

package/dist/esm/collision/sweep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sweep.js","names":[],"sources":["../../../src/collision/sweep.ts"],"sourcesContent":["import type { PointLike } from '@codexo/exojs';\n\nimport type { ShapeType } from '../shapes/Shape';\nimport { chainEdgeAdmits } from './chainAdjacency';\nimport type { CollisionProxy } from './CollisionProxy';\nimport type { PairTable } from './dispatch';\nimport { orderedEntry, orderedTable } from './dispatch';\nimport { pointSegmentDistanceSquared } from './segments';\n\n/**\n * First time of impact of a translation-only shape cast, written by\n * {@link sweepProxies} (allocation-free: the caller owns the struct).\n */\nexport interface SweepHit {\n  /** Fraction of the motion at first contact, in `(0, 1]`. */\n  t: number;\n  /** Unit surface normal on the target at the hit, pointing back toward the moving shape (opposing the motion). */\n  normalX: number;\n  /** See {@link SweepHit.normalX}. */\n  normalY: number;\n}\n\nconst eps = 1e-9;\n\n// Module-local scratch shared by the casts below. Like the narrow-phase clip\n// scratch, the sweep is single-threaded and non-reentrant - the world's CCD pass\n// calls `sweepProxies` strictly sequentially - so module-global scratch is safe.\nconst _pointScratch: PointLike = { x: 0, y: 0 };\n\n/**\n * Translation-only shape cast of `moving` against a static `target`: `moving`\n * is given at its **end-of-motion** pose (its cached world geometry) and is\n * swept from `pose − (dx, dy)` to `pose`. Rotation over the motion is not swept\n * - the moving shape keeps its end orientation for the whole cast, matching the\n * bullet CCD model (the step's rotation is applied before the sweep).\n *\n * Returns `true` with the first time of impact and the target-surface normal\n * written into `out`. Pairs already overlapping (or exactly touching) at the\n * start of the motion return `false` - they cannot tunnel within this motion\n * and the discrete solver owns them. Allocation-free.\n *\n * Boundary geometry (a segment, a chain edge) is a target, never the moving\n * operand: a chain edge blocks a bullet under the same one-sided adjacency rule\n * the discrete narrow phase applies, while a fast segment or chain is not swept\n * at all.\n */\nexport const sweepProxies = (moving: CollisionProxy, dx: number, dy: number, target: CollisionProxy, out: SweepHit): boolean => {\n  const cast = orderedEntry(sweepTable, moving.shape.type, target.shape.type);\n\n  // Unlike the narrow phase, the sweep distinguishes its operands, so this table\n  // is filled for both orders. A missing entry reports no impact - the pair is\n  // not swept at all rather than swept approximately.\n  if (cast === undefined) {\n    return false;\n  }\n\n  if (!cast(moving, dx, dy, target, out)) {\n    return false;\n  }\n\n  // `out` holds the outward normal on the target, which is the direction a chain\n  // edge has to admit for the hit to be its own.\n  return chainEdgeAdmits(target, out.normalX, out.normalY);\n};\n\n/** `true` when {@link sweepProxies} has an implementation for this ordered pair. */\nexport const canSweep = (moving: ShapeType, target: ShapeType): boolean => orderedEntry(sweepTable, moving, target) !== undefined;\n\n/**\n * Vertex count of a proxy's **core**: the geometry left once its radius is taken\n * off. A circle is a point (no core ring), a capsule and a segment are both a\n * two-vertex ring - with and without a radius - and a polygon is its own ring.\n */\nconst coreCount = (proxy: CollisionProxy): number => {\n  switch (proxy.shape.type) {\n    case 'polygon':\n      return proxy.shape.count;\n    case 'capsule':\n    case 'segment':\n      return 2;\n    case 'circle':\n    case 'chain':\n      // A chain is never an operand here - it is swept through its edge proxies.\n      return 0;\n  }\n};\n\nconst radiusOf = (proxy: CollisionProxy): number => (proxy.shape.type === 'circle' || proxy.shape.type === 'capsule' ? proxy.shape.radius : 0);\n\n/** Moving circle vs static circle: a ray against the Minkowski-summed circle. */\nconst sweepCircleCircle = (moving: CollisionProxy, dx: number, dy: number, target: CollisionProxy, out: SweepHit): boolean => {\n  const rsum = radiusOf(moving) + radiusOf(target);\n  const cx = target.worldCenter.x;\n  const cy = target.worldCenter.y;\n  // Start-of-motion centre.\n  const ox = moving.worldCenter.x - dx;\n  const oy = moving.worldCenter.y - dy;\n  const mx = ox - cx;\n  const my = oy - cy;\n\n  // Already overlapping/touching at the start: the discrete solver owns it.\n  if (mx * mx + my * my <= rsum * rsum) {\n    return false;\n  }\n\n  const a = dx * dx + dy * dy;\n  const b = mx * dx + my * dy;\n  const c = mx * mx + my * my - rsum * rsum;\n\n  if (b >= 0) {\n    // Moving away (or tangential) - no entry within the motion.\n    return false;\n  }\n\n  const disc = b * b - a * c;\n\n  if (disc < 0) {\n    return false;\n  }\n\n  const t = (-b - Math.sqrt(disc)) / a;\n\n  if (t < 0 || t > 1) {\n    return false;\n  }\n\n  out.t = t;\n  out.normalX = (ox + dx * t - cx) / rsum;\n  out.normalY = (oy + dy * t - cy) / rsum;\n\n  return true;\n};\n\n/**\n * Moving circle vs a static core ring (polygon, capsule or segment): a ray\n * against that ring inflated by both radii - offset faces plus vertex arcs, the\n * exact swept geometry.\n */\nconst sweepCircleRing = (moving: CollisionProxy, dx: number, dy: number, target: CollisionProxy, out: SweepHit): boolean => {\n  const rsum = radiusOf(moving) + radiusOf(target);\n  const ox = moving.worldCenter.x - dx;\n  const oy = moving.worldCenter.y - dy;\n  const verts = target.worldVertices;\n  const normals = target.worldNormals;\n  const count = coreCount(target);\n\n  // Already overlapping/touching at the start: the discrete solver owns it.\n  if (pointRingDistanceSquared(ox, oy, verts, normals, count) <= rsum * rsum) {\n    return false;\n  }\n\n  return castPointAtRing(ox, oy, dx, dy, rsum, verts, normals, count, out);\n};\n\n/**\n * Moving core ring (polygon or capsule) vs static circle, solved in the moving\n * shape's frame: the circle sweeps backward (`−d`) from a start displaced by\n * `+d`, against the ring's end-pose geometry - the same relative motion, so the\n * same time of impact.\n */\nconst sweepRingCircle = (moving: CollisionProxy, dx: number, dy: number, target: CollisionProxy, out: SweepHit): boolean => {\n  const rsum = radiusOf(moving) + radiusOf(target);\n  const ox = target.worldCenter.x + dx;\n  const oy = target.worldCenter.y + dy;\n  const verts = moving.worldVertices;\n  const normals = moving.worldNormals;\n  const count = coreCount(moving);\n\n  // Already overlapping/touching at the start: the discrete solver owns it.\n  if (pointRingDistanceSquared(ox, oy, verts, normals, count) <= rsum * rsum) {\n    return false;\n  }\n\n  if (!castPointAtRing(ox, oy, -dx, -dy, rsum, verts, normals, count, out)) {\n    return false;\n  }\n\n  // The cast reports the normal on the moving shape toward the circle; the\n  // caller wants the obstacle-surface normal, so flip it.\n  out.normalX = -out.normalX;\n  out.normalY = -out.normalY;\n\n  return true;\n};\n\n/**\n * Two core rings of which at least one carries a radius (any pair involving a\n * capsule): built as one configuration-space ring and cast as a point, which is\n * exact where a radius-inflated SAT would square off the rounded corners.\n */\nconst sweepRoundedRings = (moving: CollisionProxy, dx: number, dy: number, target: CollisionProxy, out: SweepHit): boolean => {\n  const rsum = radiusOf(moving) + radiusOf(target);\n\n  if (!buildConfigurationRing(moving, dx, dy, target)) {\n    return false;\n  }\n\n  const verts = _configurationRing.vertices;\n  const normals = _configurationRing.normals;\n  const count = _configurationRing.count;\n\n  // Already overlapping/touching at the start: the discrete solver owns it.\n  if (pointRingDistanceSquared(0, 0, verts, normals, count) <= rsum * rsum) {\n    return false;\n  }\n\n  return castPointAtRing(0, 0, dx, dy, rsum, verts, normals, count, out);\n};\n\n/**\n * Cast the point `(ox, oy)` along `(dx, dy)` (t ∈ [0, 1]) against `count`-vertex\n * convex ring inflated by `r`: offset faces plus vertex arcs - the exact swept\n * geometry. Writes the earliest hit into `out`; the normal points from the ring\n * surface toward the point.\n */\nconst castPointAtRing = (\n  ox: number,\n  oy: number,\n  dx: number,\n  dy: number,\n  r: number,\n  verts: readonly number[],\n  normals: readonly number[],\n  count: number,\n  out: SweepHit,\n): boolean => {\n  // Both passes only improve `out` when they beat the current `out.t`.\n  out.t = Infinity;\n  castAtOffsetFaces(ox, oy, dx, dy, r, verts, normals, count, out);\n  castAtVertexArcs(ox, oy, dx, dy, r, verts, count, out);\n\n  return out.t !== Infinity;\n};\n\n/** Offset-face pass of {@link castPointAtRing}: the face plane pushed out by `r`, hits valid within the edge span. */\nconst castAtOffsetFaces = (\n  ox: number,\n  oy: number,\n  dx: number,\n  dy: number,\n  r: number,\n  verts: readonly number[],\n  normals: readonly number[],\n  count: number,\n  out: SweepHit,\n): void => {\n  for (let i = 0; i < count; i++) {\n    // Loop indices are provably in-bounds (0..count-1); the `!` is zero-cost.\n    const nx = normals[i * 2]!;\n    const ny = normals[i * 2 + 1]!;\n    const denom = nx * dx + ny * dy;\n\n    if (denom >= 0) {\n      continue; // Not entering through this face.\n    }\n\n    const v1x = verts[i * 2]!;\n    const v1y = verts[i * 2 + 1]!;\n    const t = (nx * (v1x - ox) + ny * (v1y - oy) + r) / denom;\n\n    if (t < 0 || t > 1 || t >= out.t) {\n      continue;\n    }\n\n    const j = (i + 1) % count;\n    const v2x = verts[j * 2]!;\n    const v2y = verts[j * 2 + 1]!;\n    const ex = v2x - v1x;\n    const ey = v2y - v1y;\n    const px = ox + dx * t;\n    const py = oy + dy * t;\n    const u = (px - v1x) * ex + (py - v1y) * ey;\n\n    if (u < 0 || u > ex * ex + ey * ey) {\n      continue; // Outside the edge span — the vertex arcs own the corners.\n    }\n\n    out.t = t;\n    out.normalX = nx;\n    out.normalY = ny;\n  }\n};\n\n/** Vertex-arc pass of {@link castPointAtRing}: a ray against the circle of radius `r` around each vertex. */\nconst castAtVertexArcs = (ox: number, oy: number, dx: number, dy: number, r: number, verts: readonly number[], count: number, out: SweepHit): void => {\n  if (r <= 0) {\n    return; // A radius-free ring has no arcs; its faces meet at the vertices.\n  }\n\n  const a = dx * dx + dy * dy;\n\n  for (let i = 0; i < count; i++) {\n    const vx = verts[i * 2]!;\n    const vy = verts[i * 2 + 1]!;\n    const mx = ox - vx;\n    const my = oy - vy;\n    const b = mx * dx + my * dy;\n\n    if (b >= 0) {\n      continue; // Moving away from this vertex.\n    }\n\n    const c = mx * mx + my * my - r * r;\n\n    if (c < 0) {\n      continue; // Start inside the arc — covered by the start-overlap pre-check.\n    }\n\n    const disc = b * b - a * c;\n\n    if (disc < 0) {\n      continue;\n    }\n\n    const t = (-b - Math.sqrt(disc)) / a;\n\n    if (t < 0 || t > 1 || t >= out.t) {\n      continue;\n    }\n\n    out.t = t;\n    out.normalX = (ox + dx * t - vx) / r;\n    out.normalY = (oy + dy * t - vy) / r;\n  }\n};\n\n/**\n * Squared distance from `(px, py)` to a convex core ring, `0` inside it. A\n * two-vertex ring has no interior, so it is always the distance to the segment.\n */\nconst pointRingDistanceSquared = (px: number, py: number, verts: readonly number[], normals: readonly number[], count: number): number => {\n  if (count >= 3) {\n    let inside = true;\n\n    for (let i = 0; i < count && inside; i++) {\n      inside = normals[i * 2]! * (px - verts[i * 2]!) + normals[i * 2 + 1]! * (py - verts[i * 2 + 1]!) <= 0;\n    }\n\n    if (inside) {\n      return 0;\n    }\n  }\n\n  let best = Infinity;\n\n  for (let i = 0; i < count; i++) {\n    const j = (i + 1) % count;\n    const distance = pointSegmentDistanceSquared(px, py, verts[i * 2]!, verts[i * 2 + 1]!, verts[j * 2]!, verts[j * 2 + 1]!, _pointScratch);\n\n    best = distance < best ? distance : best;\n  }\n\n  return best;\n};\n\n/** A convex ring in world space: the only geometry the casts above work on. */\ninterface Ring {\n  vertices: number[];\n  normals: number[];\n  count: number;\n}\n\n// Scratch for the configuration-space ring and its hull pass. The arrays grow\n// to the largest pair seen and are then written in place, so a steady-state\n// bullet against known geometry allocates nothing.\nconst _configurationRing: Ring = { vertices: [], normals: [], count: 0 };\nconst _sumPoints: number[] = [];\nconst _sumOrder: number[] = [];\nconst _hull: number[] = [];\n\n/**\n * Build the pair's configuration-space obstacle into {@link _configurationRing}:\n * the Minkowski sum of the target's core and the negated start-pose core of the\n * moving shape. A translational cast of the pair is then a cast of the origin\n * point against that single ring, inflated by the two radii - which is why every\n * rounded pair reduces to {@link castPointAtRing} instead of its own algorithm.\n */\nconst buildConfigurationRing = (moving: CollisionProxy, dx: number, dy: number, target: CollisionProxy): boolean => {\n  const movingCount = coreCount(moving);\n  const targetCount = coreCount(target);\n\n  if (movingCount < 2 || targetCount < 2) {\n    return false;\n  }\n\n  const movingVerts = moving.worldVertices;\n  const targetVerts = target.worldVertices;\n  const total = movingCount * targetCount;\n\n  grow(_sumPoints, total * 2);\n  grow(_sumOrder, total);\n\n  for (let j = 0, k = 0; j < targetCount; j++) {\n    for (let i = 0; i < movingCount; i++, k++) {\n      // The moving core at the start of the motion is its end pose minus (dx, dy).\n      _sumPoints[k * 2] = targetVerts[j * 2]! - (movingVerts[i * 2]! - dx);\n      _sumPoints[k * 2 + 1] = targetVerts[j * 2 + 1]! - (movingVerts[i * 2 + 1]! - dy);\n      _sumOrder[k] = k;\n    }\n  }\n\n  const count = convexHull(total);\n\n  if (count < 2) {\n    return false;\n  }\n\n  grow(_configurationRing.vertices, count * 2);\n  grow(_configurationRing.normals, count * 2);\n  _configurationRing.count = count;\n\n  const verts = _configurationRing.vertices;\n  const normals = _configurationRing.normals;\n\n  for (let i = 0; i < count; i++) {\n    const point = _hull[i]!;\n\n    verts[i * 2] = _sumPoints[point * 2]!;\n    verts[i * 2 + 1] = _sumPoints[point * 2 + 1]!;\n  }\n\n  // Same convention as every authored ring: the outward normal of the\n  // counter-clockwise edge i → i+1 is (eY, -eX). A two-vertex ring gets the two\n  // opposite normals out of the same loop.\n  for (let i = 0; i < count; i++) {\n    const j = (i + 1) % count;\n    const ex = verts[j * 2]! - verts[i * 2]!;\n    const ey = verts[j * 2 + 1]! - verts[i * 2 + 1]!;\n    const length = Math.sqrt(ex * ex + ey * ey) || 1;\n\n    normals[i * 2] = ey / length;\n    normals[i * 2 + 1] = -ex / length;\n  }\n\n  return true;\n};\n\n/**\n * Counter-clockwise convex hull of the first `total` points in\n * {@link _sumPoints} (Andrew's monotone chain), written as point indices into\n * {@link _hull}; returns the hull size. Collinear points are dropped, so a\n * degenerate sum - two parallel spines - comes out as a two-vertex ring rather\n * than a zero-area polygon.\n */\nconst convexHull = (total: number): number => {\n  // Insertion sort by (x, y): the point sets here are a handful of vertices, and\n  // sorting in place over the index scratch keeps the pass allocation-free.\n  for (let i = 1; i < total; i++) {\n    const value = _sumOrder[i]!;\n    let j = i - 1;\n\n    while (j >= 0 && comparePoints(_sumOrder[j]!, value) > 0) {\n      _sumOrder[j + 1] = _sumOrder[j]!;\n      j--;\n    }\n\n    _sumOrder[j + 1] = value;\n  }\n\n  grow(_hull, total * 2 + 1);\n\n  let size = 0;\n\n  for (let i = 0; i < total; i++) {\n    size = pushHullPoint(_sumOrder[i]!, size, 2);\n  }\n\n  // The upper chain may not eat into the lower one, so it keeps one more point\n  // than the lower chain left behind.\n  const upperFloor = size + 1;\n\n  for (let i = total - 2; i >= 0; i--) {\n    size = pushHullPoint(_sumOrder[i]!, size, upperFloor);\n  }\n\n  // The chain closes on its starting point, which is already the first entry.\n  return size > 1 ? size - 1 : size;\n};\n\n/** One monotone-chain step: drop hull points that a left turn onto `point` makes interior. */\nconst pushHullPoint = (point: number, size: number, floor: number): number => {\n  while (size >= floor && cross(_hull[size - 2]!, _hull[size - 1]!, point) <= 0) {\n    size--;\n  }\n\n  _hull[size] = point;\n\n  return size + 1;\n};\n\nconst comparePoints = (a: number, b: number): number => {\n  const ax = _sumPoints[a * 2]!;\n  const bx = _sumPoints[b * 2]!;\n\n  if (ax !== bx) {\n    return ax < bx ? -1 : 1;\n  }\n\n  const ay = _sumPoints[a * 2 + 1]!;\n  const by = _sumPoints[b * 2 + 1]!;\n\n  if (ay === by) {\n    return 0;\n  }\n\n  return ay < by ? -1 : 1;\n};\n\n/** Cross product of `o → a` and `o → b`; positive for a counter-clockwise turn. */\nconst cross = (o: number, a: number, b: number): number => {\n  const ox = _sumPoints[o * 2]!;\n  const oy = _sumPoints[o * 2 + 1]!;\n\n  return (_sumPoints[a * 2]! - ox) * (_sumPoints[b * 2 + 1]! - oy) - (_sumPoints[a * 2 + 1]! - oy) * (_sumPoints[b * 2]! - ox);\n};\n\n/** Extend a scratch array to `length`, keeping it a plain packed number array. */\nconst grow = (array: number[], length: number): void => {\n  while (array.length < length) {\n    array.push(0);\n  }\n};\n\n// Swept-SAT accumulator shared by sweepRings's two axis passes.\n// Module-local scratch under the same single-threaded/non-reentrant contract\n// as the rest of this file.\ninterface SweptSatState {\n  tEnter: number;\n  tLeave: number;\n  normalX: number;\n  normalY: number;\n}\n\nconst _satState: SweptSatState = { tEnter: 0, tLeave: 0, normalX: 0, normalY: 0 };\n\n/**\n * Two radius-free core rings (polygon or segment) via swept SAT: for every\n * candidate axis (both rings' face normals) intersect the moving projection\n * interval with the static one over t ∈ [0, 1]; the latest entry over all axes\n * is the time of impact, and its axis (oriented against the motion) the normal.\n * Exact for linear motion of convex shapes.\n */\nconst sweepRings = (moving: CollisionProxy, dx: number, dy: number, target: CollisionProxy, out: SweepHit): boolean => {\n  const state = _satState;\n\n  state.tEnter = -Infinity;\n  state.tLeave = Infinity;\n\n  // Two passes: axes from the target, then from the moving ring. Either pass may\n  // prove the pair never meets within the motion.\n  if (!sweptSatAxes(target, moving, dx, dy, target, state) || !sweptSatAxes(moving, moving, dx, dy, target, state)) {\n    return false;\n  }\n\n  // tEnter ≤ 0 means every axis already overlapped at the start of the motion\n  // (i.e. the shapes were overlapping/touching): the discrete solver owns it.\n  if (state.tEnter <= 0 || state.tEnter > 1) {\n    return false;\n  }\n\n  out.t = state.tEnter;\n  out.normalX = state.normalX;\n  out.normalY = state.normalY;\n\n  return true;\n};\n\n/**\n * One swept-SAT axis pass over `axisOwner`'s face normals, tightening the\n * `state` entry/exit window of `moving` (translated by `(dx, dy)`, given at its\n * end pose) against the static `target`. Returns `false` as soon as an axis\n * proves the shapes never meet within the motion.\n */\nconst sweptSatAxes = (axisOwner: CollisionProxy, moving: CollisionProxy, dx: number, dy: number, target: CollisionProxy, state: SweptSatState): boolean => {\n  const axes = axisOwner.worldNormals;\n  const axisCount = coreCount(axisOwner);\n  const mv = moving.worldVertices;\n  const mc = coreCount(moving);\n  const tv = target.worldVertices;\n  const tc = coreCount(target);\n\n  for (let i = 0; i < axisCount; i++) {\n    // Loop indices are provably in-bounds; the `!` is zero-cost.\n    const nx = axes[i * 2]!;\n    const ny = axes[i * 2 + 1]!;\n    const dn = nx * dx + ny * dy;\n\n    // Project the moving ring (end pose), then shift to its start pose.\n    let minA = Infinity;\n    let maxA = -Infinity;\n\n    for (let k = 0; k < mc; k++) {\n      const p = nx * mv[k * 2]! + ny * mv[k * 2 + 1]!;\n\n      minA = p < minA ? p : minA;\n      maxA = p > maxA ? p : maxA;\n    }\n\n    minA -= dn;\n    maxA -= dn;\n\n    let minB = Infinity;\n    let maxB = -Infinity;\n\n    for (let k = 0; k < tc; k++) {\n      const p = nx * tv[k * 2]! + ny * tv[k * 2 + 1]!;\n\n      minB = p < minB ? p : minB;\n      maxB = p > maxB ? p : maxB;\n    }\n\n    if (dn > -eps && dn < eps) {\n      // No relative motion along this axis: separated - or exactly touching,\n      // which the discrete narrow phase already treats as no contact - here\n      // means never in contact.\n      if (maxA <= minB || maxB <= minA) {\n        return false;\n      }\n\n      continue;\n    }\n\n    // Entry/exit times of the moving interval against the static one.\n    const t0 = (minB - maxA) / dn;\n    const t1 = (maxB - minA) / dn;\n    const entry = t0 < t1 ? t0 : t1;\n    const exit = t0 < t1 ? t1 : t0;\n\n    if (entry > state.tEnter) {\n      state.tEnter = entry;\n      // Orient the axis against the motion (from the target toward the mover).\n      state.normalX = dn < 0 ? nx : -nx;\n      state.normalY = dn < 0 ? ny : -ny;\n    }\n\n    if (exit < state.tLeave) {\n      state.tLeave = exit;\n    }\n\n    if (state.tEnter >= state.tLeave) {\n      // Separated on one axis before overlapping on another. Equality is an\n      // exact graze (separation touches 0 but never goes negative), which the\n      // discrete narrow phase classifies as no contact.\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/** One ordered `(moving, target)` shape cast. */\ntype SweepPair = (moving: CollisionProxy, dx: number, dy: number, target: CollisionProxy, out: SweepHit) => boolean;\n\n// Every ordered pair a mass-bearing shape can move as. Boundary geometry\n// (segment, chain) appears only as a target: level structure is not swept, and\n// a fast body that needs protection carries a solid shape.\nconst sweepTable: PairTable<SweepPair> = orderedTable<SweepPair>([\n  ['circle', 'circle', sweepCircleCircle],\n  ['circle', 'capsule', sweepCircleRing],\n  ['circle', 'segment', sweepCircleRing],\n  ['circle', 'polygon', sweepCircleRing],\n  ['capsule', 'circle', sweepRingCircle],\n  ['capsule', 'capsule', sweepRoundedRings],\n  ['capsule', 'segment', sweepRoundedRings],\n  ['capsule', 'polygon', sweepRoundedRings],\n  ['polygon', 'circle', sweepRingCircle],\n  ['polygon', 'capsule', sweepRoundedRings],\n  ['polygon', 'segment', sweepRings],\n  ['polygon', 'polygon', sweepRings],\n]);\n"],"mappings":"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"}

package/dist/esm/debug/PhysicsDebugDraw.d.ts

@@ -7,7 +7,7 @@ import type { PhysicsWorld } from '../PhysicsWorld';
 export interface PhysicsDebugDrawOptions {
     /** Collider shape outlines, coloured by body type. Default `true`. */
     drawShapes?: boolean;
-    /** Collider world AABBs. Default `false`. */
+    /** World AABBs of the geometry the broad phase holds - a chain as its per-edge leaves. Default `false`. */
     drawAabb?: boolean;
     /** Contact points. Default `false`. */
     drawContacts?: boolean;
@@ -15,7 +15,7 @@ export interface PhysicsDebugDrawOptions {
     drawNormals?: boolean;
     /** Body origins (centre markers). Default `false`. */
     drawCenters?: boolean;
-    /** Broad-phase candidate links between AABB-overlapping colliders. Default `false`. */
+    /** Broad-phase candidate links between AABB-overlapping leaves - a chain links per edge. Default `false`. */
     drawBroadphase?: boolean;
     /** Tint sleeping bodies distinctly (applies to the shape outline). Default `false`. */
     drawSleeping?: boolean;
@@ -23,7 +23,7 @@ export interface PhysicsDebugDrawOptions {
     drawJoints?: boolean;
 }
 /**
- * `DebugLayer` that visualises a {@link PhysicsWorld} — shapes, AABBs, contacts,
+ * `DebugLayer` that visualises a {@link PhysicsWorld} - shapes, AABBs, contacts,
  * normals, centres and broad-phase links. It reads the world's public state and
  * recomputes contacts/broad-phase locally only while visible, so it never
  * perturbs the simulation and works over any backend. Lives in the `./debug`
@@ -34,7 +34,6 @@ export declare class PhysicsDebugDraw extends DebugLayer {
     readonly options: Required<PhysicsDebugDrawOptions>;
     private readonly _world;
     private _graphics;
-    private readonly _broadPhase;
     private readonly _manifold;
     private readonly _pairs;
     constructor(app: Application, world: PhysicsWorld, options?: PhysicsDebugDrawOptions);
@@ -45,9 +44,29 @@ export declare class PhysicsDebugDraw extends DebugLayer {
     destroy(): void;
     private _outlineColor;
     private _strokeShape;
+    /**
+     * Capsule outline: the two straight sides offset from the spine, joined by a
+     * half-circle at each end. The arcs are approximated - a visualisation may
+     * tessellate, the solver never does.
+     */
+    private _strokeCapsule;
     private _strokeAabb;
     private _strokeCircle;
     private _strokeCross;
+    /**
+     * Recomputes candidate pairs from scratch for the current frame via a plain
+     * brute-force AABB-overlap scan - deliberately NOT `AabbTreeBroadPhase`.
+     * That class relies on `Collider._treeProxy`, a field shared on the
+     * Collider object and valid only for whichever ONE broad phase currently
+     * owns it (the world's own `NativePhysicsBackend`); a second instance here
+     * would silently corrupt that ownership every time debug draw and a
+     * physics step interleave. Debug-only/opt-in (tree-shaken from production
+     * bundles), recomputed from scratch every visible frame regardless, so an
+     * O(n^2) scan is an appropriate, fully self-contained trade for
+     * correctness - it touches no state outside this method.
+     */
+    private _collectPairs;
     private _renderBroadphase;
     private _renderContacts;
 }
+//# sourceMappingURL=PhysicsDebugDraw.d.ts.map

package/dist/esm/debug/PhysicsDebugDraw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsDebugDraw.d.ts","sourceRoot":"","sources":["../../../src/debug/PhysicsDebugDraw.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAQhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD,6CAA6C;AAC7C,MAAM,WAAW,uBAAuB;IACtC,sEAAsE;IACtE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,2GAA2G;IAC3G,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uCAAuC;IACvC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,wCAAwC;IACxC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,sDAAsD;IACtD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,6GAA6G;IAC7G,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,uFAAuF;IACvF,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,kEAAkE;IAClE,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAgBD;;;;;;GAMG;AACH,qBAAa,gBAAiB,SAAQ,UAAU;IAC9C,8CAA8C;IAC9C,SAAgB,OAAO,EAAE,QAAQ,CAAC,uBAAuB,CAAC,CAAC;IAE3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;gBAE3B,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,GAAE,uBAA4B;IAgB/F,IAAoB,QAAQ,IAAI,kBAAkB,CAEjD;IAEe,MAAM,IAAI,IAAI;IAId,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IA4CpD,OAAO,CAAC,aAAa;IASL,OAAO,IAAI,IAAI;IAS/B,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,YAAY;IAwDpB;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAwBtB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,YAAY;IAOpB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAqBrB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,eAAe;CAkCxB"}

package/dist/esm/debug/PhysicsDebugDraw.js

@@ -1,195 +1,237 @@
-import { Color, Graphics } from '@codexo/exojs';
-import { DebugLayer } from '@codexo/exojs/debug';
-import { SweepAndPrune } from '../broadphase/SweepAndPrune.js';
-import { Manifold } from '../collision/Manifold.js';
-import { collide } from '../collision/narrowphase.js';
+import { aabbOverlap } from "../Aabb.js";
+import { authoredCollider } from "../Collider.js";
+import { Manifold } from "../collision/Manifold.js";
+import { collide } from "../collision/narrowphase.js";
+import { Color, Graphics } from "@codexo/exojs";
+import { DebugLayer } from "@codexo/exojs/debug";
 
+//#region src/debug/PhysicsDebugDraw.ts
 const segments = 24;
-const colorStatic = new Color(0.3, 0.9, 0.4, 0.9);
-const colorKinematic = new Color(0.4, 0.7, 1, 0.9);
-const colorDynamic = new Color(1, 0.85, 0.3, 0.9);
-const colorSensor = new Color(1, 0.3, 1, 0.9);
-const colorAabb = new Color(0.5, 0.5, 0.5, 0.5);
-const colorContact = new Color(1, 0.2, 0.2, 1);
-const colorNormal = new Color(1, 0.6, 0.1, 1);
-const colorCenter = new Color(1, 1, 1, 0.9);
-const colorBroadphase = new Color(0.2, 0.8, 0.8, 0.5);
-const colorSleeping = new Color(0.45, 0.45, 0.5, 0.7);
-const colorJoint = new Color(0.9, 0.5, 1, 0.8);
+const colorStatic = new Color(.3, .9, .4, .9);
+const colorKinematic = new Color(.4, .7, 1, .9);
+const colorDynamic = new Color(1, .85, .3, .9);
+const colorSensor = new Color(1, .3, 1, .9);
+const colorAabb = new Color(.5, .5, .5, .5);
+const colorContact = new Color(1, .2, .2, 1);
+const colorNormal = new Color(1, .6, .1, 1);
+const colorCenter = new Color(1, 1, 1, .9);
+const colorBroadphase = new Color(.2, .8, .8, .5);
+const colorSleeping = new Color(.45, .45, .5, .7);
+const colorJoint = new Color(.9, .5, 1, .8);
 /**
- * `DebugLayer` that visualises a {@link PhysicsWorld} — shapes, AABBs, contacts,
- * normals, centres and broad-phase links. It reads the world's public state and
- * recomputes contacts/broad-phase locally only while visible, so it never
- * perturbs the simulation and works over any backend. Lives in the `./debug`
- * subpath so it tree-shakes out of production bundles.
- */
-class PhysicsDebugDraw extends DebugLayer {
-    /** Mutable option flags (read each frame). */
-    options;
-    _world;
-    _graphics = null;
-    _broadPhase = new SweepAndPrune();
-    _manifold = new Manifold();
-    _pairs = [];
-    constructor(app, world, options = {}) {
-        super(app);
-        this._world = world;
-        this.options = {
-            drawShapes: options.drawShapes ?? true,
-            drawAabb: options.drawAabb ?? false,
-            drawContacts: options.drawContacts ?? false,
-            drawNormals: options.drawNormals ?? false,
-            drawCenters: options.drawCenters ?? false,
-            drawBroadphase: options.drawBroadphase ?? false,
-            drawSleeping: options.drawSleeping ?? false,
-            drawJoints: options.drawJoints ?? false,
-        };
-    }
-    get viewMode() {
-        return 'world';
-    }
-    update() {
-        // All state is read from the world in render().
-    }
-    render(backend) {
-        const gfx = (this._graphics ??= new Graphics());
-        const options = this.options;
-        gfx.clear();
-        gfx.lineWidth = 1;
-        if (options.drawBroadphase) {
-            this._renderBroadphase(gfx);
-        }
-        if (options.drawAabb) {
-            for (const collider of this._world.colliders) {
-                this._strokeAabb(gfx, collider);
-            }
-        }
-        if (options.drawShapes) {
-            for (const collider of this._world.colliders) {
-                this._strokeShape(gfx, collider);
-            }
-        }
-        if (options.drawCenters) {
-            gfx.lineColor = colorCenter;
-            for (const body of this._world.bodies) {
-                this._strokeCross(gfx, body.x, body.y, 4);
-            }
-        }
-        if (options.drawContacts || options.drawNormals) {
-            this._renderContacts(gfx);
-        }
-        if (options.drawJoints) {
-            this._renderJoints(gfx);
-        }
-        gfx.render(backend);
-    }
-    _renderJoints(gfx) {
-        gfx.lineColor = colorJoint;
-        for (const joint of this._world.joints) {
-            gfx.moveTo(joint.bodyA.x, joint.bodyA.y);
-            gfx.lineTo(joint.bodyB.x, joint.bodyB.y);
-        }
-    }
-    destroy() {
-        if (this._graphics !== null) {
-            this._graphics.destroy();
-            this._graphics = null;
-        }
-    }
-    // ── helpers ────────────────────────────────────────────────────────────
-    _outlineColor(collider) {
-        if (collider.isSensor) {
-            return colorSensor;
-        }
-        if (this.options.drawSleeping && collider.body.isSleeping) {
-            return colorSleeping;
-        }
-        return colorForType(collider.body.type);
-    }
-    _strokeShape(gfx, collider) {
-        gfx.lineColor = this._outlineColor(collider);
-        if (collider.shape.type === 'circle') {
-            const c = collider.worldCenter;
-            const r = collider.shape.radius;
-            this._strokeCircle(gfx, c.x, c.y, r);
-            // A spoke to the surface conveys orientation once bodies rotate.
-            gfx.moveTo(c.x, c.y);
-            gfx.lineTo(c.x + collider.worldTransform.cos * r, c.y + collider.worldTransform.sin * r);
-            return;
-        }
-        const verts = collider.worldVertices;
-        const count = collider.shape.count;
-        gfx.moveTo(verts[0], verts[1]);
-        for (let i = 1; i <= count; i++) {
-            const j = i % count;
-            gfx.lineTo(verts[j * 2], verts[j * 2 + 1]);
-        }
-    }
-    _strokeAabb(gfx, collider) {
-        const box = collider.aabb;
-        gfx.lineColor = colorAabb;
-        gfx.moveTo(box.minX, box.minY);
-        gfx.lineTo(box.maxX, box.minY);
-        gfx.lineTo(box.maxX, box.maxY);
-        gfx.lineTo(box.minX, box.maxY);
-        gfx.lineTo(box.minX, box.minY);
-    }
-    _strokeCircle(gfx, cx, cy, r) {
-        gfx.moveTo(cx + r, cy);
-        for (let i = 1; i <= segments; i++) {
-            const a = (i / segments) * Math.PI * 2;
-            gfx.lineTo(cx + Math.cos(a) * r, cy + Math.sin(a) * r);
-        }
-    }
-    _strokeCross(gfx, x, y, size) {
-        gfx.moveTo(x - size, y);
-        gfx.lineTo(x + size, y);
-        gfx.moveTo(x, y - size);
-        gfx.lineTo(x, y + size);
-    }
-    _renderBroadphase(gfx) {
-        this._broadPhase.computePairs(this._world.colliders, this._pairs);
-        gfx.lineColor = colorBroadphase;
-        for (const pair of this._pairs) {
-            const a = pair.a.aabb;
-            const b = pair.b.aabb;
-            gfx.moveTo((a.minX + a.maxX) * 0.5, (a.minY + a.maxY) * 0.5);
-            gfx.lineTo((b.minX + b.maxX) * 0.5, (b.minY + b.maxY) * 0.5);
-        }
-    }
-    _renderContacts(gfx) {
-        this._broadPhase.computePairs(this._world.colliders, this._pairs);
-        for (const pair of this._pairs) {
-            const a = pair.a;
-            const b = pair.b;
-            if (a.isSensor || b.isSensor) {
-                continue;
-            }
-            if (!collide(a, b, this._manifold)) {
-                continue;
-            }
-            for (let i = 0; i < this._manifold.pointCount; i++) {
-                // i in 0..pointCount-1 and pointCount ≤ 2, so the point always exists.
-                const point = i === 0 ? this._manifold.points[0] : this._manifold.points[1];
-                if (this.options.drawContacts) {
-                    gfx.lineColor = colorContact;
-                    this._strokeCross(gfx, point.x, point.y, 3);
-                }
-                if (this.options.drawNormals) {
-                    gfx.lineColor = colorNormal;
-                    gfx.moveTo(point.x, point.y);
-                    gfx.lineTo(point.x + this._manifold.normalX * 12, point.y + this._manifold.normalY * 12);
-                }
-            }
-        }
-    }
-}
+* `DebugLayer` that visualises a {@link PhysicsWorld} - shapes, AABBs, contacts,
+* normals, centres and broad-phase links. It reads the world's public state and
+* recomputes contacts/broad-phase locally only while visible, so it never
+* perturbs the simulation and works over any backend. Lives in the `./debug`
+* subpath so it tree-shakes out of production bundles.
+*/
+var PhysicsDebugDraw = class extends DebugLayer {
+	/** Mutable option flags (read each frame). */
+	options;
+	_world;
+	_graphics = null;
+	_manifold = new Manifold();
+	_pairs = [];
+	constructor(app, world, options = {}) {
+		super(app);
+		this._world = world;
+		this.options = {
+			drawShapes: options.drawShapes ?? true,
+			drawAabb: options.drawAabb ?? false,
+			drawContacts: options.drawContacts ?? false,
+			drawNormals: options.drawNormals ?? false,
+			drawCenters: options.drawCenters ?? false,
+			drawBroadphase: options.drawBroadphase ?? false,
+			drawSleeping: options.drawSleeping ?? false,
+			drawJoints: options.drawJoints ?? false
+		};
+	}
+	get viewMode() {
+		return "world";
+	}
+	update() {}
+	render(backend) {
+		const gfx = this._graphics ??= new Graphics();
+		const options = this.options;
+		gfx.clear();
+		gfx.lineWidth = 1;
+		if (options.drawBroadphase) this._renderBroadphase(gfx);
+		if (options.drawAabb) for (const collider of this._world.detectionGeometry) this._strokeAabb(gfx, collider);
+		if (options.drawShapes) for (const collider of this._world.colliders) this._strokeShape(gfx, collider);
+		if (options.drawCenters) {
+			gfx.lineColor = colorCenter;
+			for (const body of this._world.bodies) this._strokeCross(gfx, body.x, body.y, 4);
+		}
+		if (options.drawContacts || options.drawNormals) this._renderContacts(gfx);
+		if (options.drawJoints) this._renderJoints(gfx);
+		gfx.render(backend);
+	}
+	_renderJoints(gfx) {
+		gfx.lineColor = colorJoint;
+		for (const joint of this._world.joints) {
+			gfx.moveTo(joint.bodyA.x, joint.bodyA.y);
+			gfx.lineTo(joint.bodyB.x, joint.bodyB.y);
+		}
+	}
+	destroy() {
+		if (this._graphics !== null) {
+			this._graphics.destroy();
+			this._graphics = null;
+		}
+	}
+	_outlineColor(collider) {
+		if (collider.isSensor) return colorSensor;
+		if (this.options.drawSleeping && collider.body.isSleeping) return colorSleeping;
+		return colorForType(collider.body.type);
+	}
+	_strokeShape(gfx, collider) {
+		gfx.lineColor = this._outlineColor(collider);
+		if (collider.shape.type === "circle") {
+			const c = collider.worldCenter;
+			const r = collider.shape.radius;
+			this._strokeCircle(gfx, c.x, c.y, r);
+			gfx.moveTo(c.x, c.y);
+			gfx.lineTo(c.x + collider.worldTransform.cos * r, c.y + collider.worldTransform.sin * r);
+			return;
+		}
+		if (collider.shape.type === "capsule") {
+			this._strokeCapsule(gfx, collider.worldVertices, collider.shape.radius);
+			return;
+		}
+		if (collider.shape.type === "segment") {
+			const ends = collider.worldVertices;
+			gfx.moveTo(ends[0], ends[1]);
+			gfx.lineTo(ends[2], ends[3]);
+			return;
+		}
+		if (collider.shape.type === "chain") {
+			for (const edge of collider.chainEdges ?? []) {
+				const ends = edge.worldVertices;
+				gfx.moveTo(ends[0], ends[1]);
+				gfx.lineTo(ends[2], ends[3]);
+			}
+			return;
+		}
+		const verts = collider.worldVertices;
+		const count = collider.shape.count;
+		gfx.moveTo(verts[0], verts[1]);
+		for (let i = 1; i <= count; i++) {
+			const j = i % count;
+			gfx.lineTo(verts[j * 2], verts[j * 2 + 1]);
+		}
+	}
+	/**
+	* Capsule outline: the two straight sides offset from the spine, joined by a
+	* half-circle at each end. The arcs are approximated - a visualisation may
+	* tessellate, the solver never does.
+	*/
+	_strokeCapsule(gfx, spine, radius) {
+		const ax = spine[0];
+		const ay = spine[1];
+		const bx = spine[2];
+		const by = spine[3];
+		const along = Math.atan2(by - ay, bx - ax);
+		const arcSegments = 12;
+		gfx.moveTo(ax + Math.cos(along + Math.PI / 2) * radius, ay + Math.sin(along + Math.PI / 2) * radius);
+		gfx.lineTo(bx + Math.cos(along + Math.PI / 2) * radius, by + Math.sin(along + Math.PI / 2) * radius);
+		for (let i = 1; i <= arcSegments; i++) {
+			const angle = along + Math.PI / 2 - Math.PI * i / arcSegments;
+			gfx.lineTo(bx + Math.cos(angle) * radius, by + Math.sin(angle) * radius);
+		}
+		for (let i = 1; i <= arcSegments; i++) {
+			const angle = along - Math.PI / 2 - Math.PI * i / arcSegments;
+			gfx.lineTo(ax + Math.cos(angle) * radius, ay + Math.sin(angle) * radius);
+		}
+	}
+	_strokeAabb(gfx, collider) {
+		const box = collider.aabb;
+		gfx.lineColor = colorAabb;
+		gfx.moveTo(box.minX, box.minY);
+		gfx.lineTo(box.maxX, box.minY);
+		gfx.lineTo(box.maxX, box.maxY);
+		gfx.lineTo(box.minX, box.maxY);
+		gfx.lineTo(box.minX, box.minY);
+	}
+	_strokeCircle(gfx, cx, cy, r) {
+		gfx.moveTo(cx + r, cy);
+		for (let i = 1; i <= segments; i++) {
+			const a = i / segments * Math.PI * 2;
+			gfx.lineTo(cx + Math.cos(a) * r, cy + Math.sin(a) * r);
+		}
+	}
+	_strokeCross(gfx, x, y, size) {
+		gfx.moveTo(x - size, y);
+		gfx.lineTo(x + size, y);
+		gfx.moveTo(x, y - size);
+		gfx.lineTo(x, y + size);
+	}
+	/**
+	* Recomputes candidate pairs from scratch for the current frame via a plain
+	* brute-force AABB-overlap scan - deliberately NOT `AabbTreeBroadPhase`.
+	* That class relies on `Collider._treeProxy`, a field shared on the
+	* Collider object and valid only for whichever ONE broad phase currently
+	* owns it (the world's own `NativePhysicsBackend`); a second instance here
+	* would silently corrupt that ownership every time debug draw and a
+	* physics step interleave. Debug-only/opt-in (tree-shaken from production
+	* bundles), recomputed from scratch every visible frame regardless, so an
+	* O(n^2) scan is an appropriate, fully self-contained trade for
+	* correctness - it touches no state outside this method.
+	*/
+	_collectPairs() {
+		const colliders = this._world.detectionGeometry;
+		const pairs = this._pairs;
+		pairs.length = 0;
+		for (let i = 0; i < colliders.length; i++) {
+			const a = colliders[i];
+			for (let j = i + 1; j < colliders.length; j++) {
+				const b = colliders[j];
+				if (a.body !== b.body && aabbOverlap(a.aabb, b.aabb)) pairs.push(a.id < b.id ? {
+					a,
+					b
+				} : {
+					a: b,
+					b: a
+				});
+			}
+		}
+	}
+	_renderBroadphase(gfx) {
+		this._collectPairs();
+		gfx.lineColor = colorBroadphase;
+		for (const pair of this._pairs) {
+			const a = pair.a.aabb;
+			const b = pair.b.aabb;
+			gfx.moveTo((a.minX + a.maxX) * .5, (a.minY + a.maxY) * .5);
+			gfx.lineTo((b.minX + b.maxX) * .5, (b.minY + b.maxY) * .5);
+		}
+	}
+	_renderContacts(gfx) {
+		this._collectPairs();
+		for (const pair of this._pairs) {
+			const a = pair.a;
+			const b = pair.b;
+			if (authoredCollider(a).isSensor || authoredCollider(b).isSensor) continue;
+			if (!collide(a, b, this._manifold)) continue;
+			for (let i = 0; i < this._manifold.pointCount; i++) {
+				const point = i === 0 ? this._manifold.points[0] : this._manifold.points[1];
+				if (this.options.drawContacts) {
+					gfx.lineColor = colorContact;
+					this._strokeCross(gfx, point.x, point.y, 3);
+				}
+				if (this.options.drawNormals) {
+					gfx.lineColor = colorNormal;
+					gfx.moveTo(point.x, point.y);
+					gfx.lineTo(point.x + this._manifold.normalX * 12, point.y + this._manifold.normalY * 12);
+				}
+			}
+		}
+	}
+};
 const colorForType = (type) => {
-    if (type === 'static') {
-        return colorStatic;
-    }
-    return type === 'kinematic' ? colorKinematic : colorDynamic;
+	if (type === "static") return colorStatic;
+	return type === "kinematic" ? colorKinematic : colorDynamic;
 };
 
+//#endregion
 export { PhysicsDebugDraw };
-//# sourceMappingURL=PhysicsDebugDraw.js.map
+//# sourceMappingURL=PhysicsDebugDraw.js.map