@aethervtt/shard-physics 0.0.1

package/dist/pose.d.ts

@@ -0,0 +1,41 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+/**
+ * A rigid pose plus scale: translation (0..2), rotation quaternion (3..6), scale (7..9). Poses are
+ * composed from Transforms, not read from GlobalTransform, so bodies spawned before the first
+ * propagation get the right place.
+ */
+export type Pose = Float64Array;
+export declare const createPose: () => Pose;
+export declare function identityPose(out: Pose): Pose;
+/** Rotates (x, y, z) by quaternion q (offset qo) into out[oo..oo+2]. */
+export declare function rotate(out: ArrayLike<number> & {
+    [i: number]: number;
+}, oo: number, q: ArrayLike<number>, qo: number, x: number, y: number, z: number): void;
+/** out = a * b (quaternions at offsets). `out` may alias either input. */
+export declare function mulQuat(out: {
+    [i: number]: number;
+}, oo: number, a: ArrayLike<number>, ao: number, b: ArrayLike<number>, bo: number): void;
+/** The entity's parent, read from the ChildOf column (no allocation). */
+export declare function parentOf(world: World, entity: Entity): Entity | undefined;
+/** Whether an entity is a Grid (spec 0040). */
+export declare function isGrid(world: World, entity: Entity): boolean;
+/**
+ * Pose of an entity in the origin frame (where Rapier simulates), from its own and its ancestors'
+ * Transforms (up to, not including, `stop` when given: then the pose is relative to `stop`).
+ * Ignores shear from non-uniform scale under rotation, like physics shapes do. Under a Grid, the
+ * cell and the grid's frame are applied in f64, so the pose is exact however far the grid cell is
+ * from the grid's origin.
+ */
+export declare function poseOf(world: World, entity: Entity, out: Pose, stop?: Entity): Pose;
+/**
+ * The inverse of a parent's world matrix applied to an origin-frame position and rotation, for
+ * writing a body's pose back into its local Transform. Uses the parent's GlobalTransform, except
+ * when the parent is a Grid (or there is no parent and the origin is in a grid): then the grid's
+ * f64 frame, keeping the translation small by moving `child`'s GridCell when it leaves the cell
+ * (the same rule as `transform/recenter`, which then has nothing left to do).
+ */
+export declare function worldToLocal(world: World, parent: Entity | undefined, child: Entity, pos: ArrayLike<number>, rot: ArrayLike<number>, outPos: {
+    [i: number]: number;
+}, po: number, outRot: {
+    [i: number]: number;
+}, ro: number): void;

package/dist/pose.js

@@ -0,0 +1,341 @@
+import { ChildOf } from "@aethervtt/shard-core";
+import {
+  GlobalTransform,
+  Grid,
+  GridCell,
+  GridFramesResource,
+  originMatrix64,
+  Transform
+} from "@aethervtt/shard-transform";
+const createPose = () => {
+  const p = new Float64Array(10);
+  p[6] = 1;
+  p[7] = 1;
+  p[8] = 1;
+  p[9] = 1;
+  return p;
+};
+function identityPose(out) {
+  out.fill(0);
+  out[6] = 1;
+  out[7] = out[8] = out[9] = 1;
+  return out;
+}
+function rotate(out, oo, q, qo, x, y, z) {
+  const qx = q[qo];
+  const qy = q[qo + 1];
+  const qz = q[qo + 2];
+  const qw = q[qo + 3];
+  const tx = 2 * (qy * z - qz * y);
+  const ty = 2 * (qz * x - qx * z);
+  const tz = 2 * (qx * y - qy * x);
+  out[oo] = x + qw * tx + (qy * tz - qz * ty);
+  out[oo + 1] = y + qw * ty + (qz * tx - qx * tz);
+  out[oo + 2] = z + qw * tz + (qx * ty - qy * tx);
+}
+function mulQuat(out, oo, a, ao, b, bo) {
+  const ax = a[ao];
+  const ay = a[ao + 1];
+  const az = a[ao + 2];
+  const aw = a[ao + 3];
+  const bx = b[bo];
+  const by = b[bo + 1];
+  const bz = b[bo + 2];
+  const bw = b[bo + 3];
+  out[oo] = aw * bx + ax * bw + ay * bz - az * by;
+  out[oo + 1] = aw * by - ax * bz + ay * bw + az * bx;
+  out[oo + 2] = aw * bz + ax * by - ay * bx + az * bw;
+  out[oo + 3] = aw * bw - ax * bx - ay * by - az * bz;
+}
+const chain = [];
+const tmp = new Float64Array(4);
+function composeLocal(out, t, to, r, ro, s, so) {
+  rotate(tmp, 0, out, 3, out[7] * t[to], out[8] * t[to + 1], out[9] * t[to + 2]);
+  out[0] = out[0] + tmp[0];
+  out[1] = out[1] + tmp[1];
+  out[2] = out[2] + tmp[2];
+  mulQuat(out, 3, out, 3, r, ro);
+  out[7] = out[7] * s[so];
+  out[8] = out[8] * s[so + 1];
+  out[9] = out[9] * s[so + 2];
+}
+function parentOf(world, entity) {
+  const table = world.entityTableUnchecked(entity);
+  if (!table.has(ChildOf)) return void 0;
+  const p = table.column(ChildOf, "parent")[world.entityRowUnchecked(entity)];
+  return p >= 0 ? p : void 0;
+}
+function isGrid(world, entity) {
+  return world.entityTableUnchecked(entity).has(Grid);
+}
+const frame = { m: new Float64Array(12), rx: 0, ry: 0, rz: 0, cs: 0, identity: true };
+const fq = new Float64Array(4);
+function frameOf(world, grid, out) {
+  const m = out.m;
+  const frames = world.tryResource(GridFramesResource);
+  const slot = frames?.active ? grid === void 0 ? 0 : frames.slotOf.get(grid) : void 0;
+  if (slot !== void 0) {
+    const a = frames.a;
+    const o = slot * 12;
+    for (let i = 0; i < 12; i++) m[i] = a[o + i];
+    out.rx = frames.ref[slot * 3];
+    out.ry = frames.ref[slot * 3 + 1];
+    out.rz = frames.ref[slot * 3 + 2];
+    out.cs = slot === 0 ? 0 : frames.cellSize[slot];
+  } else if (grid === void 0) {
+    m.fill(0);
+    m[0] = m[5] = m[10] = 1;
+    out.rx = out.ry = out.rz = out.cs = 0;
+  } else {
+    originMatrix64(world, grid, m);
+    out.rx = out.ry = out.rz = 0;
+    const table = world.entityTableUnchecked(grid);
+    out.cs = table.column(Grid, "cellSize")[world.entityRowUnchecked(grid)];
+  }
+  out.identity = m[0] === 1 && m[1] === 0 && m[2] === 0 && m[4] === 0 && m[5] === 1 && m[6] === 0 && m[8] === 0 && m[9] === 0 && m[10] === 1;
+}
+function frameRotation(m, scale) {
+  const sx = Math.sqrt(m[0] * m[0] + m[4] * m[4] + m[8] * m[8]) || 1;
+  const sy = Math.sqrt(m[1] * m[1] + m[5] * m[5] + m[9] * m[9]) || 1;
+  const sz = Math.sqrt(m[2] * m[2] + m[6] * m[6] + m[10] * m[10]) || 1;
+  scale[0] = sx;
+  scale[1] = sy;
+  scale[2] = sz;
+  quatFromBasis(
+    fq,
+    m[0] / sx,
+    m[4] / sx,
+    m[8] / sx,
+    m[1] / sy,
+    m[5] / sy,
+    m[9] / sy,
+    m[2] / sz,
+    m[6] / sz,
+    m[10] / sz
+  );
+}
+const frameScale = new Float64Array(3);
+function applyFrame(out, f, kx, ky, kz) {
+  const m = f.m;
+  const px = (kx - f.rx) * f.cs + out[0];
+  const py = (ky - f.ry) * f.cs + out[1];
+  const pz = (kz - f.rz) * f.cs + out[2];
+  out[0] = m[0] * px + m[1] * py + m[2] * pz + m[3];
+  out[1] = m[4] * px + m[5] * py + m[6] * pz + m[7];
+  out[2] = m[8] * px + m[9] * py + m[10] * pz + m[11];
+  if (f.identity) return;
+  frameRotation(m, frameScale);
+  mulQuat(out, 3, fq, 0, out, 3);
+  out[7] = out[7] * frameScale[0];
+  out[8] = out[8] * frameScale[1];
+  out[9] = out[9] * frameScale[2];
+}
+function poseOf(world, entity, out, stop) {
+  chain.length = 0;
+  let grid;
+  let e = entity;
+  while (e !== void 0 && e !== stop) {
+    if (stop === void 0 && e !== entity && isGrid(world, e)) {
+      grid = e;
+      break;
+    }
+    chain.push(e);
+    e = parentOf(world, e);
+  }
+  identityPose(out);
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const ent = chain[i];
+    if (!world.has(ent, Transform)) continue;
+    const table2 = world.entityTable(ent);
+    const row = world.entityRow(ent);
+    composeLocal(
+      out,
+      table2.column(Transform, "translation"),
+      row * 3,
+      table2.column(Transform, "rotation"),
+      row * 4,
+      table2.column(Transform, "scale"),
+      row * 3
+    );
+  }
+  if (stop !== void 0) return out;
+  if (grid === void 0) {
+    const frames = world.tryResource(GridFramesResource);
+    if (frames === void 0 || frames.rootIdentity) return out;
+    frameOf(world, void 0, frame);
+    applyFrame(out, frame, 0, 0, 0);
+    return out;
+  }
+  const top = chain[chain.length - 1];
+  const table = world.entityTableUnchecked(top);
+  let kx = 0;
+  let ky = 0;
+  let kz = 0;
+  if (table.has(GridCell)) {
+    const cell = table.column(GridCell, "cell");
+    const o = world.entityRowUnchecked(top) * 3;
+    kx = cell[o];
+    ky = cell[o + 1];
+    kz = cell[o + 2];
+  }
+  frameOf(world, grid, frame);
+  applyFrame(out, frame, kx, ky, kz);
+  return out;
+}
+function worldToLocal(world, parent, child, pos, rot, outPos, po, outRot, ro) {
+  if (parent === void 0 || isGrid(world, parent)) {
+    gridToLocal(world, parent, child, pos, rot, outPos, po, outRot, ro);
+    return;
+  }
+  const table = world.entityTable(parent);
+  if (!table.has(GlobalTransform)) {
+    outPos[po] = pos[0];
+    outPos[po + 1] = pos[1];
+    outPos[po + 2] = pos[2];
+    outRot[ro] = rot[0];
+    outRot[ro + 1] = rot[1];
+    outRot[ro + 2] = rot[2];
+    outRot[ro + 3] = rot[3];
+    return;
+  }
+  const m = table.column(GlobalTransform, "matrix");
+  const o = world.entityRow(parent) * 12;
+  const dx = pos[0] - m[o + 3];
+  const dy = pos[1] - m[o + 7];
+  const dz = pos[2] - m[o + 11];
+  const a = m[o];
+  const b = m[o + 1];
+  const c = m[o + 2];
+  const d = m[o + 4];
+  const e = m[o + 5];
+  const f = m[o + 6];
+  const g = m[o + 8];
+  const h = m[o + 9];
+  const i = m[o + 10];
+  const A = e * i - f * h;
+  const B = -(d * i - f * g);
+  const C = d * h - e * g;
+  const det = a * A + b * B + c * C || 1;
+  const inv = 1 / det;
+  outPos[po] = (A * dx + (c * h - b * i) * dy + (b * f - c * e) * dz) * inv;
+  outPos[po + 1] = (B * dx + (a * i - c * g) * dy + (c * d - a * f) * dz) * inv;
+  outPos[po + 2] = (C * dx + (b * g - a * h) * dy + (a * e - b * d) * dz) * inv;
+  const sx = Math.sqrt(a * a + d * d + g * g) || 1;
+  const sy = Math.sqrt(b * b + e * e + h * h) || 1;
+  const sz = Math.sqrt(c * c + f * f + i * i) || 1;
+  quatFromBasis(tmp, a / sx, d / sx, g / sx, b / sy, e / sy, h / sy, c / sz, f / sz, i / sz);
+  tmp[0] = -tmp[0];
+  tmp[1] = -tmp[1];
+  tmp[2] = -tmp[2];
+  mulQuat(outRot, ro, tmp, 0, rot, 0);
+}
+function gridToLocal(world, grid, child, pos, rot, outPos, po, outRot, ro) {
+  frameOf(world, grid, frame);
+  const m = frame.m;
+  const dx = pos[0] - m[3];
+  const dy = pos[1] - m[7];
+  const dz = pos[2] - m[11];
+  let lx = dx;
+  let ly = dy;
+  let lz = dz;
+  if (!frame.identity) {
+    const a = m[0];
+    const b = m[1];
+    const c = m[2];
+    const d = m[4];
+    const e = m[5];
+    const f = m[6];
+    const g = m[8];
+    const h = m[9];
+    const i = m[10];
+    const A = e * i - f * h;
+    const B = -(d * i - f * g);
+    const C = d * h - e * g;
+    const inv = 1 / (a * A + b * B + c * C || 1);
+    lx = (A * dx + (c * h - b * i) * dy + (b * f - c * e) * dz) * inv;
+    ly = (B * dx + (a * i - c * g) * dy + (c * d - a * f) * dz) * inv;
+    lz = (C * dx + (b * g - a * h) * dy + (a * e - b * d) * dz) * inv;
+  }
+  const table = world.entityTableUnchecked(child);
+  if (grid !== void 0 && table.has(GridCell)) {
+    const cell = table.column(GridCell, "cell");
+    const row = world.entityRowUnchecked(child);
+    const o = row * 3;
+    const cs = frame.cs;
+    lx -= (cell[o] - frame.rx) * cs;
+    ly -= (cell[o + 1] - frame.ry) * cs;
+    lz -= (cell[o + 2] - frame.rz) * cs;
+    const gt = world.entityTableUnchecked(grid);
+    const limit = cs / 2 + gt.column(Grid, "hysteresis")[world.entityRowUnchecked(grid)];
+    if (lx > limit || lx < -limit || ly > limit || ly < -limit || lz > limit || lz < -limit) {
+      const jx = lx > limit || lx < -limit ? Math.round(lx / cs) : 0;
+      const jy = ly > limit || ly < -limit ? Math.round(ly / cs) : 0;
+      const jz = lz > limit || lz < -limit ? Math.round(lz / cs) : 0;
+      cell[o] = cell[o] + jx;
+      cell[o + 1] = cell[o + 1] + jy;
+      cell[o + 2] = cell[o + 2] + jz;
+      lx -= jx * cs;
+      ly -= jy * cs;
+      lz -= jz * cs;
+      table.markChanged(GridCell, row);
+    }
+  } else if (grid !== void 0) {
+    const cs = frame.cs;
+    lx += frame.rx * cs;
+    ly += frame.ry * cs;
+    lz += frame.rz * cs;
+  }
+  outPos[po] = lx;
+  outPos[po + 1] = ly;
+  outPos[po + 2] = lz;
+  if (frame.identity) {
+    outRot[ro] = rot[0];
+    outRot[ro + 1] = rot[1];
+    outRot[ro + 2] = rot[2];
+    outRot[ro + 3] = rot[3];
+    return;
+  }
+  frameRotation(m, frameScale);
+  fq[0] = -fq[0];
+  fq[1] = -fq[1];
+  fq[2] = -fq[2];
+  mulQuat(outRot, ro, fq, 0, rot, 0);
+}
+function quatFromBasis(out, m00, m10, m20, m01, m11, m21, m02, m12, m22) {
+  const trace = m00 + m11 + m22;
+  if (trace > 0) {
+    const s = 0.5 / Math.sqrt(trace + 1);
+    out[3] = 0.25 / s;
+    out[0] = (m21 - m12) * s;
+    out[1] = (m02 - m20) * s;
+    out[2] = (m10 - m01) * s;
+  } else if (m00 > m11 && m00 > m22) {
+    const s = 2 * Math.sqrt(1 + m00 - m11 - m22);
+    out[3] = (m21 - m12) / s;
+    out[0] = 0.25 * s;
+    out[1] = (m01 + m10) / s;
+    out[2] = (m02 + m20) / s;
+  } else if (m11 > m22) {
+    const s = 2 * Math.sqrt(1 + m11 - m00 - m22);
+    out[3] = (m02 - m20) / s;
+    out[0] = (m01 + m10) / s;
+    out[1] = 0.25 * s;
+    out[2] = (m12 + m21) / s;
+  } else {
+    const s = 2 * Math.sqrt(1 + m22 - m00 - m11);
+    out[3] = (m10 - m01) / s;
+    out[0] = (m02 + m20) / s;
+    out[1] = (m12 + m21) / s;
+    out[2] = 0.25 * s;
+  }
+}
+export {
+  createPose,
+  identityPose,
+  isGrid,
+  mulQuat,
+  parentOf,
+  poseOf,
+  rotate,
+  worldToLocal
+};

package/dist/world.d.ts

@@ -0,0 +1,246 @@
+import { type Entity, ShardError, type World } from '@aethervtt/shard-core';
+import type { Mesh } from '@aethervtt/shard-mesh';
+import type RAPIER from '@dimforge/rapier3d-compat';
+import { type CollisionEventData, type PhysicsConfigValue } from './components.js';
+export type Rapier = typeof RAPIER;
+type RWorld = InstanceType<Rapier['World']>;
+type RBody = InstanceType<Rapier['RigidBody']>;
+type RCollider = InstanceType<Rapier['Collider']>;
+type RJoint = InstanceType<Rapier['ImpulseJoint']>;
+/** The physics world, once Rapier has loaded (the plugin's `ready` step). */
+export declare const Physics: import("@aethervtt/shard-core").ResourceDef<PhysicsWorld>;
+/** Loads and initializes Rapier's WASM for a dimension, once per process. */
+export declare function loadRapier(dim: 2 | 3): Promise<Rapier>;
+/** A body the physics world owns, by entity. */
+export interface BodyRecord {
+    entity: Entity;
+    handle: number;
+    body: RBody;
+    kind: number;
+    /** Dense index into the interpolation buffers. */
+    slot: number;
+    /** Position in `PhysicsWorld.list`. */
+    index: number;
+    /** Out of PhysicsRange: disabled in Rapier, the entity has PhysicsParked. */
+    parked: boolean;
+}
+/** A character's Rapier controller and the body and capsule it moves. */
+export interface CharacterRecord {
+    entity: Entity;
+    body: BodyRecord;
+    collider: RCollider;
+    kcc: InstanceType<Rapier['KinematicCharacterController']>;
+    /** Whether snap-to-ground is on right now (off while moving up, so jumps leave the ground). */
+    snapping: boolean;
+    snapDistance: number;
+    /** Cosine of maxSlope: ground normals at least this aligned with up are walkable. */
+    cosMaxSlope: number;
+    /** From the capsule's center to its bottom, m. */
+    bottom: number;
+}
+/** The gap Rapier keeps between a character and what it touches, m. */
+export declare const CHARACTER_OFFSET = 0.01;
+export interface RayHit {
+    /** The collider's entity. */
+    entity: Entity;
+    /** The body it belongs to, or -1 for a fixed collider without a body. */
+    body: Entity;
+    distance: number;
+    point: Float32Array;
+    normal: Float32Array;
+}
+export declare const createRayHit: () => RayHit;
+export interface QueryOptions {
+    /** Longest ray or cast, m (default: no limit). */
+    maxDistance?: number;
+    /** Only colliders in these layers (bitmask, default all). */
+    mask?: number;
+    /** The query's own layers, for colliders whose mask filters queries (default all). */
+    layers?: number;
+    /** Skip this entity's colliders (and its body's). */
+    exclude?: Entity;
+    /** A ray starting inside a shape hits at distance 0 (default true). */
+    solid?: boolean;
+    /** Include sensors (default false). */
+    sensors?: boolean;
+}
+export interface QueryShape {
+    shape: 'ball' | 'cuboid' | 'capsule';
+    radius?: number;
+    halfExtents?: ArrayLike<number>;
+    halfHeight?: number;
+}
+export interface PhysicsStats {
+    bodies: Record<string, number>;
+    sleeping: number;
+    colliders: Record<string, number>;
+    joints: number;
+    /** Character controllers (not counted in bodies or colliders). */
+    characters: number;
+    contacts: number;
+    stepMs: number;
+    steps: number;
+    pending: number;
+    /** Bodies out of PhysicsRange, set aside until the origin comes near (spec 0040). */
+    parked: number;
+}
+/**
+ * The Rapier world for one app, plus the maps between Rapier handles and entities. Systems in
+ * `plugin.ts` keep it in sync with the components; queries read it.
+ */
+export declare class PhysicsWorld {
+    readonly R: Rapier;
+    readonly dim: 2 | 3;
+    readonly raw: RWorld;
+    readonly events: InstanceType<Rapier['EventQueue']>;
+    readonly bodies: Map<number, BodyRecord>;
+    /** Every body record, for loops that shouldn't allocate an iterator. */
+    readonly list: BodyRecord[];
+    readonly bodyByHandle: Map<number, BodyRecord>;
+    readonly colliders: Map<number, RAPIER.Collider>;
+    readonly colliderEntity: Map<number, number>;
+    /** Collider entity → the body entity it's attached to (absent: fixed). */
+    readonly colliderOwner: Map<number, number>;
+    /** Shape kind per collider entity, for describe and the overlay. */
+    readonly colliderShape: Map<number, "ball" | "capsule" | "cone" | "convex" | "cuboid" | "cylinder" | "heightfield" | "polyline" | "segment" | "trimesh">;
+    readonly joints: Map<number, {
+        joint: RJoint;
+        a: Entity;
+        b: Entity;
+    }>;
+    /** Character controllers by entity; each also has a body record and a capsule collider. */
+    readonly characters: Map<number, CharacterRecord>;
+    /** Colliders to (re)build at the next sync, e.g. after their body changed. */
+    readonly dirtyColliders: Set<number>;
+    readonly dirtyJoints: Set<number>;
+    readonly dirtyBodies: Set<number>;
+    /** Collider entities waiting for their mesh to load. */
+    readonly pendingMesh: Set<number>;
+    /** Mesh colliders and the mesh version they were built from, to rebuild on hot reload. */
+    readonly meshColliders: Map<number, {
+        mesh: Mesh;
+        version: number;
+    }>;
+    /** Last step's poses (slot × 7: translation, rotation), and the ones before, for interpolation. */
+    prev: Float64Array<ArrayBuffer>;
+    curr: Float64Array<ArrayBuffer>;
+    private freeSlots;
+    private nextSlot;
+    /** Ticks: when sync-out last wrote Transforms, and when interpolation did. */
+    writeTick: number;
+    interpTick: number;
+    /** Whether the world had grids at the last sync (spec 0040), so a change resyncs every body. */
+    gridsActive: boolean;
+    /** Bodies parked out of PhysicsRange. */
+    parkedCount: number;
+    stepMs: number;
+    steps: number;
+    readonly config: PhysicsConfigValue;
+    private readonly scratchPose;
+    private readonly scratchPose2;
+    readonly v3: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    readonly q4: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    readonly rawVec: unknown | undefined;
+    private readonly ray;
+    private logged;
+    constructor(R: Rapier, dim: 2 | 3, config: PhysicsConfigValue);
+    gravityVector(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Writes a vector into the reused {x, y, z} object (Rapier's 2D API ignores z). */
+    vec(x: number, y: number, z: number): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** A rotation for Rapier from a quaternion at offset o (in 2D, its angle around Z). */
+    rotation(q: ArrayLike<number>, o?: number): RAPIER.Rotation;
+    /** Logs a problem once per entity and code, so a bad collider doesn't flood the log. */
+    report(world: World, entity: Entity, err: ShardError): void;
+    /** Slots the interpolation buffers hold. */
+    get slotCapacity(): number;
+    private allocSlot;
+    createBody(world: World, entity: Entity): void;
+    private addBody;
+    removeBody(world: World, entity: Entity): void;
+    /** Copies a body's current pose into `curr` at its slot. */
+    storePose(record: BodyRecord): void;
+    /** Teleports a body (or sets a kinematic target) to the entity's current world pose. */
+    moveBody(world: World, record: BodyRecord, wake?: boolean): void;
+    setVelocity(world: World, record: BodyRecord): void;
+    /**
+     * The floating origin moved: `offset` (m) takes a position in the old origin frame to the new
+     * one. Moves every body and free collider by it without waking them (velocities and contacts
+     * are relative, so they don't change), shifts the interpolation buffers, and refreshes the
+     * broad phase with a zero-length step so queries see the new places before the next step.
+     * O(bodies), once per cell crossing.
+     */
+    shiftOrigin(ox: number, oy: number, oz: number, onCollision: (e: CollisionEventData) => void): void;
+    /**
+     * The frame Rapier simulates in changed without an OriginShift (grids appeared or went away):
+     * puts every body and free collider back where its Transform says.
+     */
+    resync(world: World): void;
+    /**
+     * Parks bodies farther than `radius` from the origin and brings parked ones back within
+     * 0.95 × radius. Active bodies are measured by their last simulated pose, parked ones by their
+     * GlobalTransform. Allocation-free unless a body changes state.
+     */
+    updateParking(world: World, radius: number): void;
+    /** Takes a body out of the simulation, storing its velocity on PhysicsParked. */
+    park(world: World, record: BodyRecord): void;
+    /** Puts a parked body back where its Transform says, moving with its stored velocity. */
+    unpark(world: World, record: BodyRecord): void;
+    /** Grids went away: nothing is out of range any more. */
+    unparkAll(world: World): void;
+    /**
+     * (Re)builds a character's kinematic body, capsule collider, and Rapier controller from its
+     * CharacterController. The capsule is centered on the entity, its axis along the entity's +Y.
+     */
+    createCharacter(world: World, entity: Entity): void;
+    private markSubtreeColliders;
+    /** Marks colliders and bodies under an entity whose place in the hierarchy changed. */
+    reparented(world: World, entity: Entity): void;
+    private forgetCollider;
+    removeCollider(entity: Entity): void;
+    /** The nearest ancestor-or-self with a body. */
+    ownerOf(world: World, entity: Entity): Entity | undefined;
+    createCollider(world: World, entity: Entity): void;
+    private meshFor;
+    /** Scales every collider's density so the body weighs exactly its Mass. */
+    fixMass(world: World, owner: Entity): void;
+    private shapeDesc;
+    /** Shape points as a flat array for the current dimension, scaled. */
+    private points;
+    removeJoint(entity: Entity): void;
+    createJoint(world: World, entity: Entity): void;
+    step(dt: number, onCollision: (e: CollisionEventData) => void, onForce: (a: Entity, b: Entity, f: number) => void): void;
+    private filter;
+    /** The nearest hit along a ray, written into `out`. Direction needn't be normalized. */
+    raycast(origin: ArrayLike<number>, direction: ArrayLike<number>, options: QueryOptions | undefined, out: RayHit): boolean;
+    /** Every hit along a ray, nearest first. Cold path. */
+    raycastAll(origin: ArrayLike<number>, direction: ArrayLike<number>, options?: QueryOptions): RayHit[];
+    private queryShape;
+    /** Sweeps a shape along `velocity` × maxDistance; the first hit's entity and distance. */
+    shapeCast(shape: QueryShape, position: ArrayLike<number>, rotation: ArrayLike<number>, direction: ArrayLike<number>, options: QueryOptions | undefined, out: RayHit): boolean;
+    /** Calls `visit` for each collider entity containing the point; return false to stop. */
+    overlapPoint(point: ArrayLike<number>, options: QueryOptions | undefined, visit: (entity: Entity) => boolean | undefined): void;
+    /** Calls `visit` for each collider entity overlapping the shape; return false to stop. */
+    overlapShape(shape: QueryShape, position: ArrayLike<number>, rotation: ArrayLike<number>, options: QueryOptions | undefined, visit: (entity: Entity) => boolean | undefined): void;
+    describe(): PhysicsStats;
+    free(): void;
+}
+/** Angle around Z of a quaternion (2D rotation). */
+export declare function quatToAngle(q: ArrayLike<number>, o?: number): number;
+export {};