@aethervtt/shard-physics 0.0.1

package/dist/plugin.js

@@ -0,0 +1,853 @@
+import {
+  ChildOf,
+  defineSystem,
+  defineSystemSet,
+  FixedUpdate,
+  onAdd,
+  onRemove,
+  onSet,
+  PostUpdate,
+  ShardError
+} from "@aethervtt/shard-core";
+import { defineOverlay } from "@aethervtt/shard-render";
+import { FixedTime } from "@aethervtt/shard-runtime";
+import {
+  GlobalTransform,
+  GridCell,
+  GridFramesResource,
+  OriginShift,
+  Transform,
+  TransformSystems
+} from "@aethervtt/shard-transform";
+import { characterSystem } from "./character.js";
+import * as componentsModule from "./components.js";
+import {
+  CharacterController,
+  CharacterState,
+  Collider,
+  CollisionEvent,
+  ContactForceEvent,
+  ExternalForce,
+  ExternalImpulse,
+  GravitySource,
+  Joint,
+  PhysicsConfig,
+  PhysicsRange,
+  RigidBody,
+  Velocity
+} from "./components.js";
+import { createGravitySources, gatherGravitySources, sampleGravity } from "./gravity.js";
+import { physicsMethods } from "./methods.js";
+import * as pluginModule from "./plugin.js";
+import { isGrid, parentOf, rotate, worldToLocal } from "./pose.js";
+import { loadRapier, Physics, PhysicsWorld } from "./world.js";
+const PhysicsSystems = defineSystemSet("physics/PhysicsSystems");
+function physics(world) {
+  const p = world.tryResource(Physics);
+  if (!p) {
+    throw new ShardError("physics/not-ready", "Physics is not ready", {
+      hint: "Add the physics3d or physics2d plugin and await app.init() before querying."
+    });
+  }
+  return p;
+}
+const KIND_DYNAMIC = 0;
+const KIND_FIXED = 1;
+const KIND_KINEMATIC_POSITION = 2;
+const reparented = /* @__PURE__ */ new WeakMap();
+const syncIn = defineSystem({
+  name: "physics/sync-in",
+  description: "Creates and rebuilds bodies, colliders, and joints from component changes; pushes teleports, velocities, forces, and gravity sources into Rapier.",
+  setup: (world) => ({
+    bodies: world.query({ with: [RigidBody] }),
+    colliders: world.query({ with: [Collider] }),
+    joints: world.query({ with: [Joint] }),
+    velocities: world.query({ with: [Velocity, RigidBody] }),
+    impulses: world.query({ with: [ExternalImpulse] }),
+    forces: world.query({ with: [ExternalForce] }),
+    sources: world.query({ with: [GravitySource, GlobalTransform] }),
+    forcedLast: [],
+    forcedNow: [],
+    stamp: 0,
+    stamps: new Uint32Array(64),
+    gravity: createGravitySources(),
+    pull: new Float64Array(4),
+    gravityVisit: void 0
+  }),
+  run: (s, world, ctx) => {
+    const p = world.tryResource(Physics);
+    if (!p) return;
+    const since = ctx.lastRunTick;
+    const moved = reparented.get(world);
+    if (moved && moved.size > 0) {
+      for (const e of moved) p.reparented(world, e);
+      moved.clear();
+    }
+    const userTick = Math.max(p.writeTick, p.interpTick);
+    if (p.config.interpolate && p.interpTick > p.writeTick) restorePoses(world, p);
+    const frames = world.tryResource(GridFramesResource);
+    const gridsActive = frames?.active === true;
+    if (gridsActive !== p.gridsActive) {
+      p.gridsActive = gridsActive;
+      p.resync(world);
+    }
+    for (let t = 0; t < s.bodies.tables.length; t++) {
+      const table = s.bodies.tables[t];
+      if (table.lastChanged(RigidBody) <= since) continue;
+      const ticks = table.changedTicks(RigidBody);
+      for (let row = 0; row < table.count; row++) {
+        if (ticks[row] > since) p.createBody(world, table.entities[row]);
+      }
+    }
+    if (p.dirtyBodies.size > 0) {
+      for (const e of p.dirtyBodies) {
+        const record = p.bodies.get(e);
+        if (record && world.isAlive(e)) p.moveBody(world, record);
+      }
+      p.dirtyBodies.clear();
+    }
+    for (let t = 0; t < s.colliders.tables.length; t++) {
+      const table = s.colliders.tables[t];
+      if (table.lastChanged(Collider) <= since) continue;
+      const ticks = table.changedTicks(Collider);
+      for (let row = 0; row < table.count; row++) {
+        if (ticks[row] > since) p.dirtyColliders.add(table.entities[row]);
+      }
+    }
+    if (p.meshColliders.size > 0) {
+      for (const [e, m] of p.meshColliders)
+        if (m.mesh.version !== m.version) p.dirtyColliders.add(e);
+    }
+    if (p.pendingMesh.size > 0) for (const e of p.pendingMesh) p.dirtyColliders.add(e);
+    if (p.dirtyColliders.size > 0) {
+      for (const e of p.dirtyColliders) {
+        if (world.isAlive(e) && world.has(e, Collider)) p.createCollider(world, e);
+      }
+      p.dirtyColliders.clear();
+    }
+    for (let t = 0; t < s.joints.tables.length; t++) {
+      const table = s.joints.tables[t];
+      if (table.lastChanged(Joint) <= since) continue;
+      const ticks = table.changedTicks(Joint);
+      for (let row = 0; row < table.count; row++) {
+        if (ticks[row] > since) p.dirtyJoints.add(table.entities[row]);
+      }
+    }
+    if (p.dirtyJoints.size > 0) {
+      for (const e of p.dirtyJoints) {
+        if (!world.isAlive(e) || !world.has(e, Joint)) {
+          p.dirtyJoints.delete(e);
+          continue;
+        }
+        p.createJoint(world, e);
+        if (p.joints.has(e)) p.dirtyJoints.delete(e);
+      }
+    }
+    for (let t = 0; t < s.bodies.tables.length; t++) {
+      const table = s.bodies.tables[t];
+      const kinematicMoved = table.lastChanged(GlobalTransform) > since;
+      const cells = table.has(GridCell) && table.lastChanged(GridCell) > userTick ? table.changedTicks(GridCell) : void 0;
+      if (table.lastChanged(Transform) <= userTick && !kinematicMoved && cells === void 0) {
+        continue;
+      }
+      const ticks = table.changedTicks(Transform);
+      const globals = table.changedTicks(GlobalTransform);
+      for (let row = 0; row < table.count; row++) {
+        const record = p.bodies.get(table.entities[row]);
+        if (!record) continue;
+        if (ticks[row] > userTick || cells !== void 0 && cells[row] > userTick) {
+          p.moveBody(world, record);
+        } else if (record.kind === KIND_KINEMATIC_POSITION && globals[row] > since) {
+          p.moveBody(world, record);
+        }
+      }
+    }
+    for (let t = 0; t < s.velocities.tables.length; t++) {
+      const table = s.velocities.tables[t];
+      if (table.lastChanged(Velocity) <= userTick) continue;
+      const ticks = table.changedTicks(Velocity);
+      for (let row = 0; row < table.count; row++) {
+        if (ticks[row] <= userTick) continue;
+        const record = p.bodies.get(table.entities[row]);
+        if (record && record.kind !== KIND_FIXED) p.setVelocity(world, record);
+      }
+    }
+    for (let t = 0; t < s.impulses.tables.length; t++) {
+      const table = s.impulses.tables[t];
+      if (table.lastChanged(ExternalImpulse) <= since) continue;
+      const imp = table.column(ExternalImpulse, "impulse");
+      const tor = table.column(ExternalImpulse, "torque");
+      const ticks = table.changedTicks(ExternalImpulse);
+      let wrote = false;
+      for (let row = 0; row < table.count; row++) {
+        if (ticks[row] <= since) continue;
+        const o = row * 3;
+        const record = p.bodies.get(table.entities[row]);
+        if (!record || record.kind !== KIND_DYNAMIC) continue;
+        if (imp[o] || imp[o + 1] || imp[o + 2]) {
+          record.body.applyImpulse(p.vec(imp[o], imp[o + 1], imp[o + 2]), true);
+        }
+        if (tor[o] || tor[o + 1] || tor[o + 2]) {
+          if (p.dim === 3)
+            record.body.applyTorqueImpulse(p.vec(tor[o], tor[o + 1], tor[o + 2]), true);
+          else
+            record.body.applyTorqueImpulse(tor[o + 2], true);
+        }
+        imp[o] = imp[o + 1] = imp[o + 2] = 0;
+        tor[o] = tor[o + 1] = tor[o + 2] = 0;
+        wrote = true;
+      }
+      if (wrote) table.markChanged(ExternalImpulse);
+    }
+    applyForces(s, p, since);
+    if (gridsActive) p.updateParking(world, world.resource(PhysicsRange).radius);
+    else if (p.parkedCount > 0) p.unparkAll(world);
+  }
+});
+const scratchPos = new Float64Array(3);
+const scratchRot = new Float64Array(4);
+function rootIsOrigin(world) {
+  return world.tryResource(GridFramesResource)?.rootIdentity !== false;
+}
+function writeMode(world, entity, rootIdentity) {
+  const parent = parentOf(world, entity);
+  if (parent === void 0) return rootIdentity ? 0 : 1;
+  return isGrid(world, parent) ? 1 : -1;
+}
+function writeGridPose(world, entity, table, row, pos, rot, dim) {
+  const tr = table.column(Transform, "translation");
+  const z = tr[row * 3 + 2];
+  worldToLocal(
+    world,
+    parentOf(world, entity),
+    entity,
+    pos,
+    rot,
+    tr,
+    row * 3,
+    table.column(Transform, "rotation"),
+    row * 4
+  );
+  if (dim === 2) tr[row * 3 + 2] = z;
+  table.markChanged(Transform, row);
+}
+function restorePoses(world, p) {
+  const rootIdentity = rootIsOrigin(world);
+  for (let i = 0; i < p.list.length; i++) {
+    const r = p.list[i];
+    if (r.kind === KIND_FIXED || r.kind === KIND_KINEMATIC_POSITION || r.parked) continue;
+    const table = world.entityTableUnchecked(r.entity);
+    const row = world.entityRowUnchecked(r.entity);
+    if (table.changedTicks(Transform)[row] !== p.interpTick) continue;
+    const mode = writeMode(world, r.entity, rootIdentity);
+    if (mode < 0) continue;
+    if (mode === 0) {
+      writePose(table, row, p.curr, r.slot * 7, p.dim);
+      continue;
+    }
+    const o = r.slot * 7;
+    for (let k = 0; k < 3; k++) scratchPos[k] = p.curr[o + k];
+    for (let k = 0; k < 4; k++) scratchRot[k] = p.curr[o + 3 + k];
+    writeGridPose(world, r.entity, table, row, scratchPos, scratchRot, p.dim);
+  }
+}
+function writePose(table, row, pose, o, dim) {
+  const tr = table.column(Transform, "translation");
+  const rot = table.column(Transform, "rotation");
+  tr[row * 3] = pose[o];
+  tr[row * 3 + 1] = pose[o + 1];
+  if (dim === 3) tr[row * 3 + 2] = pose[o + 2];
+  rot[row * 4] = pose[o + 3];
+  rot[row * 4 + 1] = pose[o + 4];
+  rot[row * 4 + 2] = pose[o + 5];
+  rot[row * 4 + 3] = pose[o + 6];
+  table.markChanged(Transform, row);
+}
+function applyForces(s, p, since) {
+  const raw = p.raw.bodies.raw;
+  const rv = p.rawVec;
+  for (let i = 0; i < s.forcedLast.length; i++) {
+    const r = s.forcedLast[i];
+    if (!p.bodyByHandle.has(r.handle)) continue;
+    raw.rbResetForces(r.handle, false);
+    raw.rbResetTorques(r.handle, false);
+  }
+  const swap = s.forcedLast;
+  s.forcedLast = s.forcedNow;
+  s.forcedNow = swap;
+  s.forcedNow.length = 0;
+  s.stamp++;
+  if (s.stamps.length < p.slotCapacity) {
+    const grown = new Uint32Array(p.slotCapacity);
+    grown.set(s.stamps);
+    s.stamps = grown;
+  }
+  for (let t = 0; t < s.forces.tables.length; t++) {
+    const table = s.forces.tables[t];
+    const f = table.column(ExternalForce, "force");
+    const tq = table.column(ExternalForce, "torque");
+    const ticks = table.changedTicks(ExternalForce);
+    for (let row = 0; row < table.count; row++) {
+      const record = p.bodies.get(table.entities[row]);
+      if (!record || record.kind !== KIND_DYNAMIC) continue;
+      const o = row * 3;
+      const wake = ticks[row] > since;
+      if (s.stamps[record.slot] !== s.stamp) {
+        s.stamps[record.slot] = s.stamp;
+        s.forcedLast.push(record);
+      }
+      if (f[o] || f[o + 1] || f[o + 2]) {
+        rv.x = f[o];
+        rv.y = f[o + 1];
+        if (p.dim === 3) rv.z = f[o + 2];
+        raw.rbAddForce(record.handle, rv, wake);
+      }
+      if (tq[o] || tq[o + 1] || tq[o + 2]) {
+        if (p.dim === 3) {
+          rv.x = tq[o];
+          rv.y = tq[o + 1];
+          rv.z = tq[o + 2];
+          raw.rbAddTorque(record.handle, rv, wake);
+        } else {
+          ;
+          raw.rbAddTorque(
+            record.handle,
+            tq[o + 2],
+            wake
+          );
+        }
+      }
+    }
+  }
+  gatherGravitySources(s.sources, s.gravity);
+  if (s.gravity.count === 0) return;
+  s.gravityVisit ??= (handle) => {
+    const record = p.bodyByHandle.get(handle);
+    if (!record || record.kind !== KIND_DYNAMIC) return;
+    const c = p.curr;
+    const o = record.slot * 7;
+    const g = s.pull;
+    sampleGravity(s.gravity, p.dim, c[o], c[o + 1], c[o + 2], false, g);
+    const k = record.body.mass() * record.body.gravityScale();
+    if (s.stamps[record.slot] !== s.stamp) {
+      s.stamps[record.slot] = s.stamp;
+      s.forcedLast.push(record);
+    }
+    rv.x = g[0] * k;
+    rv.y = g[1] * k;
+    if (p.dim === 3) rv.z = g[2] * k;
+    raw.rbAddForce(handle, rv, false);
+  };
+  p.raw.islands.forEachActiveRigidBodyHandle(s.gravityVisit);
+}
+const step = defineSystem({
+  name: "physics/step",
+  description: "Steps Rapier by the fixed timestep and sends collision and contact force events.",
+  setup: (world) => ({
+    onCollision: (e) => world.send(CollisionEvent, e),
+    onForce: (a, b, force) => world.send(ContactForceEvent, { a, b, force })
+  }),
+  run: (s, world) => {
+    const p = world.tryResource(Physics);
+    if (!p || p.config.paused) return;
+    p.step(world.resource(FixedTime).step, s.onCollision, s.onForce);
+  }
+});
+function cacheTable(c, table) {
+  c.table = table;
+  c.tr = table.column(Transform, "translation");
+  c.rt = table.column(Transform, "rotation");
+  c.trTicks = table.changedTicks(Transform);
+  table.touch(Transform);
+  if (table.has(Velocity)) {
+    c.lin = table.column(Velocity, "linear");
+    c.ang = table.column(Velocity, "angular");
+    c.velTicks = table.changedTicks(Velocity);
+    table.touch(Velocity);
+  } else {
+    c.lin = c.ang = c.velTicks = void 0;
+  }
+  c.parented = table.has(ChildOf);
+}
+const syncOut = defineSystem({
+  name: "physics/sync-out",
+  description: "Writes the poses and velocities of moving bodies to Transform and Velocity.",
+  setup: (world) => ({
+    visit: void 0,
+    world,
+    tick: 0,
+    pos: new Float64Array(3),
+    rot: new Float64Array(4),
+    rootIdentity: true,
+    cache: {
+      table: void 0,
+      tr: new Float32Array(0),
+      rt: new Float32Array(0),
+      trTicks: new Uint32Array(0),
+      lin: void 0,
+      ang: void 0,
+      velTicks: void 0,
+      parented: false
+    }
+  }),
+  run: (s, world, ctx) => {
+    const p = world.tryResource(Physics);
+    if (!p) return;
+    p.writeTick = ctx.thisRunTick;
+    s.tick = ctx.thisRunTick;
+    s.cache.table = void 0;
+    s.rootIdentity = rootIsOrigin(world);
+    s.visit ??= (handle) => {
+      const record = p.bodyByHandle.get(handle);
+      if (!record || record.kind === KIND_FIXED) return;
+      const o = record.slot * 7;
+      const curr = p.curr;
+      for (let k = 0; k < 7; k++) p.prev[o + k] = curr[o + k];
+      p.storePose(record);
+      const e = record.entity;
+      const table = world.entityTableUnchecked(e);
+      const row = world.entityRowUnchecked(e);
+      const c = s.cache;
+      if (c.table !== table) cacheTable(c, table);
+      if (record.kind !== KIND_KINEMATIC_POSITION) {
+        const parent = c.parented ? parentOf(world, e) : void 0;
+        const tr = c.tr;
+        const rt = c.rt;
+        if (parent === void 0 && s.rootIdentity) {
+          tr[row * 3] = curr[o];
+          tr[row * 3 + 1] = curr[o + 1];
+          if (p.dim === 3) tr[row * 3 + 2] = curr[o + 2];
+          rt[row * 4] = curr[o + 3];
+          rt[row * 4 + 1] = curr[o + 4];
+          rt[row * 4 + 2] = curr[o + 5];
+          rt[row * 4 + 3] = curr[o + 6];
+        } else {
+          for (let k = 0; k < 3; k++) s.pos[k] = curr[o + k];
+          for (let k = 0; k < 4; k++) s.rot[k] = curr[o + 3 + k];
+          const z = tr[row * 3 + 2];
+          worldToLocal(world, parent, e, s.pos, s.rot, tr, row * 3, rt, row * 4);
+          if (p.dim === 2) tr[row * 3 + 2] = z;
+        }
+        c.trTicks[row] = s.tick;
+      }
+      if (c.lin) {
+        const lin = c.lin;
+        const ang = c.ang;
+        const v = record.body.linvel(p.v3);
+        lin[row * 3] = v.x;
+        lin[row * 3 + 1] = v.y;
+        lin[row * 3 + 2] = p.dim === 3 ? v.z : 0;
+        if (p.dim === 3) {
+          const a = record.body.angvel(p.v3);
+          ang[row * 3] = a.x;
+          ang[row * 3 + 1] = a.y;
+          ang[row * 3 + 2] = a.z;
+        } else {
+          ang[row * 3] = 0;
+          ang[row * 3 + 1] = 0;
+          ang[row * 3 + 2] = record.body.angvel();
+        }
+        c.velTicks[row] = s.tick;
+      }
+    };
+    p.raw.islands.forEachActiveRigidBodyHandle(s.visit);
+  }
+});
+const interpolate = defineSystem({
+  name: "physics/interpolate",
+  description: "With PhysicsConfig.interpolate, blends body Transforms between the last two steps by FixedTime.alpha.",
+  run: (_, world, ctx) => {
+    const p = world.tryResource(Physics);
+    if (!p?.config.interpolate) return;
+    const alpha = world.resource(FixedTime).alpha;
+    const ours = Math.max(p.writeTick, p.interpTick);
+    const prev = p.prev;
+    const curr = p.curr;
+    const rootIdentity = rootIsOrigin(world);
+    const pos = scratchPos;
+    const rot = scratchRot;
+    for (let i = 0; i < p.list.length; i++) {
+      const r = p.list[i];
+      if (r.kind === KIND_FIXED || r.kind === KIND_KINEMATIC_POSITION || r.parked) continue;
+      const table = world.entityTableUnchecked(r.entity);
+      const row = world.entityRowUnchecked(r.entity);
+      if (table.changedTicks(Transform)[row] > ours) continue;
+      const mode = writeMode(world, r.entity, rootIdentity);
+      if (mode < 0) continue;
+      const o = r.slot * 7;
+      pos[0] = prev[o] + (curr[o] - prev[o]) * alpha;
+      pos[1] = prev[o + 1] + (curr[o + 1] - prev[o + 1]) * alpha;
+      pos[2] = prev[o + 2] + (curr[o + 2] - prev[o + 2]) * alpha;
+      let ax = prev[o + 3];
+      let ay = prev[o + 4];
+      let az = prev[o + 5];
+      let aw = prev[o + 6];
+      const bx = curr[o + 3];
+      const by = curr[o + 4];
+      const bz = curr[o + 5];
+      const bw = curr[o + 6];
+      if (ax * bx + ay * by + az * bz + aw * bw < 0) {
+        ax = -ax;
+        ay = -ay;
+        az = -az;
+        aw = -aw;
+      }
+      const x = ax + (bx - ax) * alpha;
+      const y = ay + (by - ay) * alpha;
+      const z = az + (bz - az) * alpha;
+      const w = aw + (bw - aw) * alpha;
+      const len = Math.sqrt(x * x + y * y + z * z + w * w) || 1;
+      rot[0] = x / len;
+      rot[1] = y / len;
+      rot[2] = z / len;
+      rot[3] = w / len;
+      if (mode === 1) {
+        writeGridPose(world, r.entity, table, row, pos, rot, p.dim);
+        continue;
+      }
+      const tr = table.column(Transform, "translation");
+      const rt = table.column(Transform, "rotation");
+      tr[row * 3] = pos[0];
+      tr[row * 3 + 1] = pos[1];
+      if (p.dim === 3) tr[row * 3 + 2] = pos[2];
+      rt[row * 4] = rot[0];
+      rt[row * 4 + 1] = rot[1];
+      rt[row * 4 + 2] = rot[2];
+      rt[row * 4 + 3] = rot[3];
+      table.markChanged(Transform, row);
+    }
+    p.interpTick = ctx.thisRunTick;
+  }
+});
+const dimensionOf = /* @__PURE__ */ new WeakMap();
+function observe(world) {
+  const get = () => world.tryResource(Physics);
+  world.observe(onRemove(RigidBody), (e) => get()?.removeBody(world, e.entity));
+  world.observe(onRemove(CharacterController), (e) => {
+    const p = get();
+    if (p?.characters.has(e.entity)) p.removeBody(world, e.entity);
+  });
+  world.observe(onRemove(Collider), (e) => {
+    const p = get();
+    p?.removeCollider(e.entity);
+    p?.pendingMesh.delete(e.entity);
+  });
+  world.observe(onRemove(Joint), (e) => {
+    const p = get();
+    p?.removeJoint(e.entity);
+    p?.dirtyJoints.delete(e.entity);
+  });
+  let set = reparented.get(world);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    reparented.set(world, set);
+  }
+  const moved = set;
+  const mark = (e) => void moved.add(e.entity);
+  world.observe(onAdd(ChildOf), mark);
+  world.observe(onSet(ChildOf), mark);
+  world.observe(onRemove(ChildOf), mark);
+  const onCollision = (e) => world.send(CollisionEvent, e);
+  world.observe(OriginShift, ({ data }) => {
+    get()?.shiftOrigin(data.offset[0], data.offset[1], data.offset[2], onCollision);
+  });
+}
+function physicsPlugin(dim) {
+  return {
+    name: dim === 3 ? "physics3d" : "physics2d",
+    provides: [componentsModule, pluginModule],
+    dependencies: ["core/transform"],
+    build(app) {
+      const other = dimensionOf.get(app.world);
+      if (other !== void 0 && other !== dim) {
+        throw new ShardError(
+          "physics/both-dimensions",
+          "physics2d and physics3d are both enabled",
+          { hint: "Enable one physics plugin per app: physics3d for 3D games, physics2d for 2D." }
+        );
+      }
+      dimensionOf.set(app.world, dim);
+      app.world.initResource(PhysicsConfig);
+      app.world.initResource(PhysicsRange);
+      if (dim === 2) {
+        const config = app.world.resource(PhysicsConfig);
+        config.gravity = [0, -9.81, 0];
+      }
+      observe(app.world);
+      app.addSystems(
+        FixedUpdate,
+        syncIn.inSet(PhysicsSystems),
+        characterSystem.after(syncIn).inSet(PhysicsSystems),
+        step.after(characterSystem).inSet(PhysicsSystems),
+        syncOut.after(step).inSet(PhysicsSystems)
+      );
+      app.addSystems(PostUpdate, interpolate.before(TransformSystems));
+      app.addMethod(...physicsMethods);
+    },
+    async ready(app) {
+      const R = await loadRapier(dim);
+      app.world.insertResource(Physics, new PhysicsWorld(R, dim, app.world.resource(PhysicsConfig)));
+    }
+  };
+}
+const physics3dPlugin = physicsPlugin(3);
+const physics2dPlugin = physicsPlugin(2);
+const COLORS = [
+  [1, 0.55, 0.2, 1],
+  // dynamic
+  [0.55, 0.55, 0.6, 1],
+  // fixed
+  [0.3, 0.8, 1, 1],
+  // kinematic
+  [0.3, 0.8, 1, 1]
+];
+const SLEEPING = [0.5, 0.35, 0.2, 1];
+const SENSOR = [0.3, 1, 0.4, 1];
+const CONTACT = [1, 0.2, 0.3, 1];
+const UP = [1, 0.9, 0.2, 1];
+const pa = new Float64Array(3);
+const pb = new Float64Array(3);
+const q = new Float64Array(4);
+const center = new Float64Array(3);
+const collidersOverlay = defineOverlay({
+  name: "colliders",
+  description: "Physics collider outlines, colored by body kind (sleeping dimmed, sensors green, characters cyan with their up in yellow), and contact normals.",
+  draw(world, g, passes) {
+    const p = world.tryResource(Physics);
+    if (!p) return;
+    for (const [entity, collider] of p.colliders) {
+      if (!passes(entity)) continue;
+      const owner = p.colliderOwner.get(entity);
+      const record = owner === void 0 ? void 0 : p.bodies.get(owner);
+      const color = collider.isSensor() ? SENSOR : record?.body.isSleeping() ? SLEEPING : COLORS[record?.kind ?? KIND_FIXED];
+      const t = collider.translation(p.v3);
+      center[0] = t.x;
+      center[1] = t.y;
+      center[2] = p.dim === 3 ? t.z : 0;
+      if (p.dim === 3) {
+        const r = collider.rotation(p.q4);
+        q[0] = r.x;
+        q[1] = r.y;
+        q[2] = r.z;
+        q[3] = r.w;
+      } else {
+        const angle = collider.rotation();
+        q[0] = 0;
+        q[1] = 0;
+        q[2] = Math.sin(angle / 2);
+        q[3] = Math.cos(angle / 2);
+      }
+      drawCollider(p, g, collider, p.colliderShape.get(entity), color);
+    }
+    for (const [entity, c] of p.characters) {
+      if (!passes(entity) || !world.has(entity, CharacterState)) continue;
+      const up = world.get(entity, CharacterState).up;
+      const t = c.collider.translation(p.v3);
+      const tall = p.colliderShape.get(entity) === "capsule" ? c.collider.halfHeight() : 0;
+      const reach = c.collider.radius() + tall + 0.5;
+      pa[0] = t.x;
+      pa[1] = t.y;
+      pa[2] = p.dim === 3 ? t.z : 0;
+      pb[0] = pa[0] + up[0] * reach;
+      pb[1] = pa[1] + up[1] * reach;
+      pb[2] = pa[2] + up[2] * reach;
+      g.line(pa, pb, UP);
+    }
+    contactBudget = MAX_CONTACT_PAIRS;
+    for (let i = 0; i < p.list.length && contactBudget > 0; i++) {
+      const record = p.list[i];
+      if (record.kind !== KIND_DYNAMIC || record.body.isSleeping()) continue;
+      const n = record.body.numColliders();
+      for (let c = 0; c < n; c++) drawContacts(p, g, record.body.collider(c));
+    }
+  }
+});
+const MAX_CONTACT_PAIRS = 1e3;
+let contactBudget = 0;
+function visitedFromOtherSide(other) {
+  const body = other.parent();
+  return body?.isDynamic() === true && !body.isSleeping();
+}
+function drawContacts(p, g, collider) {
+  p.raw.contactPairsWith(collider, (other) => {
+    if (contactBudget <= 0) return;
+    if (other.handle < collider.handle && visitedFromOtherSide(other)) return;
+    contactBudget--;
+    p.raw.contactPair(collider, other, (manifold) => {
+      const count = manifold.numSolverContacts();
+      if (count === 0) return;
+      const n = manifold.normal();
+      for (let i = 0; i < count; i++) {
+        const point = manifold.solverContactPoint(i);
+        if (!point) continue;
+        pa[0] = point.x;
+        pa[1] = point.y;
+        pa[2] = p.dim === 3 ? point.z : 0;
+        pb[0] = pa[0] + n.x * 0.25;
+        pb[1] = pa[1] + n.y * 0.25;
+        pb[2] = pa[2] + (p.dim === 3 ? n.z : 0) * 0.25;
+        g.line(pa, pb, CONTACT);
+      }
+    });
+  });
+}
+function local(out, x, y, z) {
+  rotate(out, 0, q, 0, x, y, z);
+  out[0] = out[0] + center[0];
+  out[1] = out[1] + center[1];
+  out[2] = out[2] + center[2];
+  return out;
+}
+const SEGMENTS = 24;
+const UNIT = (() => {
+  const out = new Float64Array((SEGMENTS + 1) * 2);
+  for (let i = 0; i <= SEGMENTS; i++) {
+    const t = i / SEGMENTS * Math.PI * 2;
+    out[i * 2] = Math.cos(t);
+    out[i * 2 + 1] = Math.sin(t);
+  }
+  return out;
+})();
+function localCircle(g, axis, r, dy, color) {
+  for (let i = 0; i <= SEGMENTS; i++) {
+    const u = UNIT[i * 2] * r;
+    const v = UNIT[i * 2 + 1] * r;
+    if (axis === 0) local(pb, 0, u + dy, v);
+    else if (axis === 1) local(pb, u, dy, v);
+    else local(pb, u, v + dy, 0);
+    if (i > 0) g.line(pa, pb, color);
+    pa[0] = pb[0];
+    pa[1] = pb[1];
+    pa[2] = pb[2];
+  }
+}
+function drawCollider(p, g, collider, shape, color) {
+  const is2d = p.dim === 2;
+  switch (shape) {
+    case "ball": {
+      const r = collider.radius();
+      localCircle(g, 2, r, 0, color);
+      if (!is2d) {
+        localCircle(g, 0, r, 0, color);
+        localCircle(g, 1, r, 0, color);
+      }
+      return;
+    }
+    case "cuboid": {
+      const he = collider.halfExtents();
+      const hz = is2d ? 0 : he.z;
+      const size = [he.x * 2, he.y * 2, hz * 2];
+      g.box(center, size, q, color);
+      return;
+    }
+    case "capsule":
+    case "cylinder":
+    case "cone": {
+      const r = collider.radius();
+      const h = collider.halfHeight();
+      if (is2d) {
+        local(pa, -r, -h, 0);
+        local(pb, -r, h, 0);
+        g.line(pa, pb, color);
+        local(pa, r, -h, 0);
+        local(pb, r, h, 0);
+        g.line(pa, pb, color);
+        localCircle(g, 2, r, h, color);
+        localCircle(g, 2, r, -h, color);
+        return;
+      }
+      const top = shape === "cone" ? 0 : r;
+      localCircle(g, 1, r, -h, color);
+      if (top > 0) localCircle(g, 1, top, h, color);
+      for (let k = 0; k < 4; k++) {
+        const a = k / 4 * Math.PI * 2;
+        local(pa, Math.cos(a) * r, -h, Math.sin(a) * r);
+        local(pb, Math.cos(a) * top, h, Math.sin(a) * top);
+        g.line(pa, pb, color);
+      }
+      if (shape === "capsule") {
+        localCircle(g, 0, r, h, color);
+        localCircle(g, 0, r, -h, color);
+        localCircle(g, 2, r, h, color);
+        localCircle(g, 2, r, -h, color);
+      }
+      return;
+    }
+    case "heightfield":
+      drawHeightfield(p, g, collider, color);
+      return;
+    default: {
+      const vertices = collider.vertices?.();
+      const indices = collider.indices?.();
+      if (!vertices || vertices.length === 0) return;
+      const d = p.dim;
+      const edge = (i, j) => {
+        local(pa, vertices[i * d], vertices[i * d + 1], d === 3 ? vertices[i * d + 2] : 0);
+        local(pb, vertices[j * d], vertices[j * d + 1], d === 3 ? vertices[j * d + 2] : 0);
+        g.line(pa, pb, color);
+      };
+      if (indices && indices.length > 0) {
+        const stride = shape === "polyline" || is2d ? 2 : 3;
+        const limit = Math.min(indices.length, 3e4);
+        for (let i = 0; i + stride - 1 < limit; i += stride) {
+          for (let k = 0; k < stride; k++) {
+            if (stride === 2 && k === 1) break;
+            edge(indices[i + k], indices[i + (k + 1) % stride]);
+          }
+        }
+      } else {
+        const n = vertices.length / d;
+        for (let i = 0; i + 1 < n; i++) edge(i, i + 1);
+        if (shape === "convex" && n > 2) edge(n - 1, 0);
+      }
+    }
+  }
+}
+function drawHeightfield(p, g, collider, color) {
+  const hf = collider;
+  const heights = hf.heightfieldHeights();
+  const scale = hf.heightfieldScale();
+  if (p.dim === 2) {
+    const n = heights.length;
+    for (let i = 0; i < n; i++) {
+      local(pb, (i / (n - 1) - 0.5) * scale.x, heights[i] * scale.y, 0);
+      if (i > 0) g.line(pa, pb, color);
+      pa[0] = pb[0];
+      pa[1] = pb[1];
+      pa[2] = pb[2];
+    }
+    return;
+  }
+  const rows = hf.heightfieldNRows() + 1;
+  const cols = hf.heightfieldNCols() + 1;
+  const sz = scale.z ?? 1;
+  const at = (out, r, c) => local(
+    out,
+    (c / (cols - 1) - 0.5) * scale.x,
+    heights[c * rows + r] * scale.y,
+    (r / (rows - 1) - 0.5) * sz
+  );
+  const step2 = Math.max(1, Math.ceil(Math.max(rows, cols) / 64));
+  for (let r = 0; r < rows; r += step2) {
+    for (let c = 0; c + step2 < cols; c += step2) {
+      at(pa, r, c);
+      at(pb, r, c + step2);
+      g.line(pa, pb, color);
+    }
+  }
+  for (let c = 0; c < cols; c += step2) {
+    for (let r = 0; r + step2 < rows; r += step2) {
+      at(pa, r, c);
+      at(pb, r + step2, c);
+      g.line(pa, pb, color);
+    }
+  }
+}
+export {
+  Physics,
+  PhysicsSystems,
+  collidersOverlay,
+  physics,
+  physics2dPlugin,
+  physics3dPlugin
+};