@irtio/client 0.5.2 → 0.7.0

package/dist/physics-RT5T36P5.js

@@ -0,0 +1,219 @@
+import {
+  Predictor
+} from "./chunk-DABQDR3S.js";
+import "./chunk-XWVXZRBS.js";
+
+// src/physics.ts
+function readPose(body, into) {
+  const t = body.translation();
+  const r = body.rotation();
+  const v = body.linvel();
+  const w = body.angvel();
+  into.t.x = t.x;
+  into.t.y = t.y;
+  into.t.z = t.z;
+  into.r.x = r.x;
+  into.r.y = r.y;
+  into.r.z = r.z;
+  into.r.w = r.w;
+  into.v.x = v.x;
+  into.v.y = v.y;
+  into.v.z = v.z;
+  into.w.x = w.x;
+  into.w.y = w.y;
+  into.w.z = w.z;
+}
+var engine;
+var loading;
+async function loadEngine() {
+  if (engine) return engine;
+  loading ??= (async () => {
+    const mod = await import("@dimforge/rapier3d-compat");
+    const ns = mod.default ?? mod;
+    await ns.init();
+    engine = ns;
+    return ns;
+  })();
+  return loading;
+}
+function planarLockWarning(spec) {
+  const boxed = (spec.colliders ?? []).some(
+    (c) => c.shape.type === CUBOID_SHAPE || c.shape.type === ROUND_CUBOID_SHAPE
+  );
+  if (!boxed) return void 0;
+  const b = spec.body;
+  const t = [b.translationsEnabledX, b.translationsEnabledY, b.translationsEnabledZ];
+  const r = [b.rotationsEnabledX, b.rotationsEnabledY, b.rotationsEnabledZ];
+  const axes = ["x", "y", "z"];
+  for (let i = 0; i < 3; i++) {
+    if (t[i]) continue;
+    if (r[(i + 1) % 3] || r[(i + 2) % 3]) continue;
+    const free = axes[i] === "z" ? "enabledRotations(true, false, true)" : "one of the other two rotations";
+    return `locks translation on ${axes[i]} and both rotations across that plane on a box-shaped body. That removes friction entirely: the box slides at a constant speed until it hits something. Free one out-of-plane rotation \u2014 in the xy plane that is ${free}, and it costs nothing, because geometry symmetric about the plane generates no torque about it.`;
+  }
+  return void 0;
+}
+var CUBOID_SHAPE = 1;
+var ROUND_CUBOID_SHAPE = 12;
+var RapierAdapter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  engineName = "@dimforge/rapier3d-compat";
+  optionName = "physics";
+  rapier;
+  world;
+  get timestep() {
+    return this.options.timestep;
+  }
+  async start(timestepSeconds) {
+    const rapier = await loadEngine();
+    this.rapier = rapier;
+    const world = new rapier.World({ ...this.options.gravity });
+    world.timestep = timestepSeconds;
+    if (this.options.setup) this.options.setup(world, rapier);
+    this.world = world;
+  }
+  free() {
+    this.world?.free();
+    this.world = void 0;
+  }
+  hasFactory(collection) {
+    return this.options.bodies?.[collection] !== void 0;
+  }
+  createBody(desc, id, record, warn) {
+    const world = this.world;
+    const rapier = this.rapier;
+    const factory = this.options.bodies?.[desc.name];
+    if (!world || !rapier || !factory) return void 0;
+    const spec = factory(rapier, record, id);
+    if (!spec || !spec.body) return void 0;
+    const planar = planarLockWarning(spec);
+    if (planar !== void 0) {
+      warn(`planar:${desc.name}`, `irtio: physics.bodies.${desc.name} ${planar}`);
+    }
+    const body = world.createRigidBody(spec.body);
+    for (const collider of spec.colliders ?? []) world.createCollider(collider, body);
+    return body;
+  }
+  removeBody(body) {
+    this.world?.removeRigidBody(body);
+  }
+  /**
+   * D71: a proxy is a `KinematicPositionBased` body — driven by the position it is told to be at
+   * next, never by a force, an impulse or a contact. Rapier derives the velocity its contacts see
+   * from the move itself, which is what carries a predicted body standing on a moving platform.
+   *
+   * The body is *switched* rather than built kinematic, so its collider, mass properties and axis
+   * locks are the ones the shared factory produced. A proxy has to be the server's body, and the
+   * only way to keep that true is to run the same factory call the predicted path runs.
+   */
+  makeKinematic(handle) {
+    const rapier = this.rapier;
+    if (!rapier) return;
+    handle.setBodyType(rapier.RigidBodyType.KinematicPositionBased, true);
+  }
+  moveKinematic(handle, pose) {
+    const body = handle;
+    body.setNextKinematicTranslation(pose.t);
+    body.setNextKinematicRotation(pose.r);
+  }
+  step() {
+    this.world?.step();
+  }
+  /** Server record → body channels (the same mapping the runtime's sync uses, inverted). */
+  applyRecord(handle, channels, record) {
+    const body = handle;
+    const t = { ...body.translation() };
+    const r = { ...body.rotation() };
+    const v = { ...body.linvel() };
+    const w = { ...body.angvel() };
+    let setT = false;
+    let setR = false;
+    let setV = false;
+    let setW = false;
+    for (const [channel, field] of channels) {
+      const raw = record[field];
+      if (typeof raw !== "number") continue;
+      switch (channel) {
+        case "x":
+        case "y":
+        case "z":
+          t[channel] = raw;
+          setT = true;
+          break;
+        case "qx":
+          r.x = raw;
+          setR = true;
+          break;
+        case "qy":
+          r.y = raw;
+          setR = true;
+          break;
+        case "qz":
+          r.z = raw;
+          setR = true;
+          break;
+        case "qw":
+          r.w = raw;
+          setR = true;
+          break;
+        case "vx":
+          v.x = raw;
+          setV = true;
+          break;
+        case "vy":
+          v.y = raw;
+          setV = true;
+          break;
+        case "vz":
+          v.z = raw;
+          setV = true;
+          break;
+        case "wx":
+          w.x = raw;
+          setW = true;
+          break;
+        case "wy":
+          w.y = raw;
+          setW = true;
+          break;
+        case "wz":
+          w.z = raw;
+          setW = true;
+          break;
+      }
+    }
+    if (setT) body.setTranslation(t, true);
+    if (setR) body.setRotation(r, true);
+    if (setV) body.setLinvel(v, true);
+    if (setW) body.setAngvel(w, true);
+  }
+  readPose(body, into) {
+    readPose(body, into);
+  }
+  applyIntent(collection, body, instance) {
+    const hook = this.options.intents?.[collection];
+    const world = this.world;
+    const rapier = this.rapier;
+    if (!hook || !world || !rapier) return;
+    hook(body, instance, rapier, world);
+  }
+  /** Rapier velocities are per second, so one tick of error is `epsilon` when `dv = eps / dt`. */
+  velocityTolerance(epsilon, timestepSeconds) {
+    return epsilon / timestepSeconds;
+  }
+};
+var PhysicsPredictor = class extends Predictor {
+  constructor(ext, store, options, meOf, rttOf, tickIntervalOf, log = (m) => console.warn(m)) {
+    super(ext, store, new RapierAdapter(options), options, meOf, rttOf, tickIntervalOf, log);
+  }
+};
+function createRapierAdapter(options) {
+  return new RapierAdapter(options);
+}
+export {
+  PhysicsPredictor,
+  createRapierAdapter
+};

package/dist/physics2d-HOFMWPZV.js

@@ -0,0 +1,255 @@
+import {
+  Predictor
+} from "./chunk-DABQDR3S.js";
+import "./chunk-XWVXZRBS.js";
+
+// src/physics2d.ts
+import {
+  angleFrom2d,
+  applyChannel2d,
+  channelOf2d
+} from "@irtio/schema";
+var MATTER_BASE_DELTA = 1 / 60;
+var engine;
+var loading;
+async function loadEngine() {
+  if (engine) return engine;
+  loading ??= (async () => {
+    const mod = await import("matter-js");
+    const ns = mod.default ?? mod;
+    engine = ns;
+    return ns;
+  })();
+  return loading;
+}
+var MatterAdapter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  engineName = "matter-js";
+  optionName = "physics2d";
+  matter;
+  engine;
+  /** The fixed delta `Engine.update` is given, in milliseconds — the room's, never a frame's. */
+  stepMs = 1e3 / 30;
+  timestepSeconds = 1 / 30;
+  /** A factory's constraints, so `removeBody` takes them out with the body they pinned. */
+  constraints = /* @__PURE__ */ new WeakMap();
+  /** Reused by `readPose` and `applyRecord`, which run per body per step and must not allocate. */
+  state = {
+    x: 0,
+    y: 0,
+    angle: 0,
+    vx: 0,
+    vy: 0,
+    angularVelocity: 0
+  };
+  /** `applyChannel2d`'s target shape, likewise reused. */
+  channels = { x: 0, y: 0, qz: 0, qw: 1, vx: 0, vy: 0, wz: 0 };
+  /** `moveKinematic`'s position argument, reused: it runs per proxy per step (D71). */
+  moveTarget = { x: 0, y: 0 };
+  get timestep() {
+    return this.options.timestep;
+  }
+  async start(timestepSeconds) {
+    const matter = await loadEngine();
+    this.matter = matter;
+    this.timestepSeconds = timestepSeconds;
+    this.stepMs = timestepSeconds * 1e3;
+    const engine2 = matter.Engine.create();
+    engine2.gravity.x = this.options.gravity.x;
+    engine2.gravity.y = this.options.gravity.y;
+    if (this.options.setup) this.options.setup(engine2, matter);
+    this.engine = engine2;
+  }
+  free() {
+    if (this.matter && this.engine) this.matter.Engine.clear(this.engine);
+    this.engine = void 0;
+  }
+  hasFactory(collection) {
+    return this.options.bodies?.[collection] !== void 0;
+  }
+  createBody(desc, id, record, warn) {
+    const matter = this.matter;
+    const engine2 = this.engine;
+    const factory = this.options.bodies?.[desc.name];
+    if (!matter || !engine2 || !factory) return void 0;
+    const spec = factory(matter, record, id);
+    if (!spec || !spec.body) return void 0;
+    if (spec.body.isStatic && this.options.settle?.[desc.name] !== void 0) {
+      warn(
+        `settle-static:${desc.name}`,
+        `irtio: physics2d.settle.${desc.name} runs on static bodies, which matter.js never integrates, so the force does nothing. Drop the settle hook for that collection.`
+      );
+    }
+    const constraints = spec.constraints ?? [];
+    matter.Composite.add(engine2.world, [spec.body, ...constraints]);
+    if (constraints.length > 0) this.constraints.set(spec.body, constraints);
+    return spec.body;
+  }
+  removeBody(handle) {
+    const matter = this.matter;
+    const engine2 = this.engine;
+    if (!matter || !engine2) return;
+    const body = handle;
+    const pinned = this.constraints.get(body);
+    matter.Composite.remove(engine2.world, pinned ? [body, ...pinned] : [body]);
+    this.constraints.delete(body);
+  }
+  /**
+   * D71: matter.js has no kinematic body type. Static is the only kind it never integrates and
+   * never moves from an impulse, so that is what a proxy is.
+   *
+   * `Body.setStatic` also overwrites the surface properties the factory set — `friction` to 1 and
+   * `restitution` to 0, on every part, and on a body that was *already* static it does that without
+   * even stashing the old values in `_original`. A proxy has to be the server's body rather than a
+   * stickier copy of it (matter pairs friction as the minimum of the two, so a proxy at friction 1
+   * is only invisible while the other body is the grippier one), so the factory's values are
+   * snapshotted here and put back. Mass and inertia keep the infinities that make it immovable.
+   */
+  makeKinematic(handle) {
+    const matter = this.matter;
+    if (!matter) return;
+    const body = handle;
+    const parts = body.parts;
+    const surfaces = parts.map((p) => ({ friction: p.friction, restitution: p.restitution }));
+    matter.Body.setStatic(body, true);
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const surface = surfaces[i];
+      part.friction = surface.friction;
+      part.restitution = surface.restitution;
+    }
+  }
+  /**
+   * `updateVelocity: true` is the whole mechanism. It leaves `positionPrev` exactly one move behind
+   * the new position, and matter's resolver reads a body's velocity as precisely that difference
+   * (`Resolver.solveVelocity`: `position - positionPrev`), so a predicted body resting on the proxy
+   * is carried by friction the way it is on the server. Given the same pose twice the difference is
+   * zero and the proxy is at rest, which is what holds it still through a rebase's re-steps.
+   *
+   * The third parameter is real in matter-js 0.20 (`src/body/Body.js`) and missing from
+   * `@types/matter-js@0.20.2` on both setters, which is what the two casts are for.
+   */
+  moveKinematic(handle, pose) {
+    const matter = this.matter;
+    if (!matter) return;
+    const body = handle;
+    const setPosition = matter.Body.setPosition;
+    const setAngle = matter.Body.setAngle;
+    const to = this.moveTarget;
+    to.x = pose.t.x;
+    to.y = pose.t.y;
+    setPosition(body, to, true);
+    setAngle(body, angleFrom2d(pose.r.z, pose.r.w), true);
+  }
+  step() {
+    if (!this.matter || !this.engine) return;
+    this.matter.Engine.update(this.engine, this.stepMs);
+  }
+  /**
+   * Server record → body state, in `applyRecordToBody`'s order.
+   *
+   * Position before velocity and angle before spin, matching the server. In matter-js 0.20 the
+   * two orders happen to agree — `setPosition` shifts `positionPrev` by the same delta, so it
+   * preserves the velocity either way — but the server's order is the one to keep: it is the
+   * order the runtime's `applyRecordToBody` uses, and a version that stopped agreeing would break
+   * both sides the same way rather than only this one.
+   *
+   * Then the body is woken. A rebase writes state a sleeping body would ignore, the same reason
+   * Rapier's setters are called with `wakeUp = true`. matter's `enableSleeping` is off by default
+   * on both sides, so this is usually a no-op, and it is here for the room that turns it on.
+   */
+  applyRecord(handle, channels, record) {
+    const matter = this.matter;
+    if (!matter) return;
+    const body = handle;
+    const t = this.channels;
+    t.x = body.position.x;
+    t.y = body.position.y;
+    t.qz = Math.sin(body.angle / 2);
+    t.qw = Math.cos(body.angle / 2);
+    t.vx = body.velocity.x;
+    t.vy = body.velocity.y;
+    t.wz = body.angularVelocity;
+    for (const [channel, field] of channels) {
+      const raw = record[field];
+      if (typeof raw !== "number") continue;
+      applyChannel2d(channel, raw, t);
+    }
+    matter.Body.setPosition(body, { x: t.x, y: t.y });
+    matter.Body.setAngle(body, angleFrom2d(t.qz, t.qw));
+    matter.Body.setVelocity(body, { x: t.vx, y: t.vy });
+    matter.Body.setAngularVelocity(body, t.wz);
+    matter.Sleeping.set(body, false);
+  }
+  /**
+   * Body state → a 3D pose, through `channelOf2d` so the plane-to-channel mapping stays written
+   * once, in `@irtio/schema`: `t = (x, y, 0)`, `r` a quaternion about Z, `v = (vx, vy, 0)`,
+   * `w = (0, 0, spin)`.
+   */
+  readPose(handle, into) {
+    const body = handle;
+    const s = this.state;
+    s.x = body.position.x;
+    s.y = body.position.y;
+    s.angle = body.angle;
+    s.vx = body.velocity.x;
+    s.vy = body.velocity.y;
+    s.angularVelocity = body.angularVelocity;
+    const b = s;
+    into.t.x = channelOf2d("x", b);
+    into.t.y = channelOf2d("y", b);
+    into.t.z = channelOf2d("z", b);
+    into.r.x = channelOf2d("qx", b);
+    into.r.y = channelOf2d("qy", b);
+    into.r.z = channelOf2d("qz", b);
+    into.r.w = channelOf2d("qw", b);
+    into.v.x = channelOf2d("vx", b);
+    into.v.y = channelOf2d("vy", b);
+    into.v.z = channelOf2d("vz", b);
+    into.w.x = channelOf2d("wx", b);
+    into.w.y = channelOf2d("wy", b);
+    into.w.z = channelOf2d("wz", b);
+  }
+  applyIntent(collection, body, instance) {
+    this.run(this.options.intents?.[collection], body, instance);
+  }
+  settle(collection, body, instance) {
+    this.run(this.options.settle?.[collection], body, instance);
+  }
+  run(hook, body, instance) {
+    const matter = this.matter;
+    const engine2 = this.engine;
+    if (!hook || !matter || !engine2) return;
+    hook(body, instance, matter, engine2, this.timestepSeconds);
+  }
+  /**
+   * What one step of a velocity disagreement moves the body by, inverted.
+   *
+   * Rapier's velocities are per second, so its answer is `epsilon / dt`. matter's are neither per
+   * second nor, strictly, per step: `Body.updateVelocities` normalises `body.velocity` against
+   * `Body._baseDelta` at the end of every `Engine.update`, and `Body.setVelocity` reads the same
+   * units back, so a velocity is a displacement per sixtieth of a second whatever the room's step
+   * is (verified against matter-js 0.20.0's `Body.js`). One step moves a body by
+   * `v * dt / baseDelta`, so the tolerance divides by exactly that ratio — which is 1, and the
+   * answer plain `epsilon`, in the 60 Hz room this was designed for.
+   */
+  velocityTolerance(epsilon, timestepSeconds) {
+    const perStep = timestepSeconds / MATTER_BASE_DELTA;
+    return perStep > 0 ? epsilon / perStep : epsilon;
+  }
+};
+var Physics2dPredictor = class extends Predictor {
+  constructor(ext, store, options, meOf, rttOf, tickIntervalOf, log = (m) => console.warn(m)) {
+    super(ext, store, new MatterAdapter(options), options, meOf, rttOf, tickIntervalOf, log);
+  }
+};
+function createMatterAdapter(options) {
+  return new MatterAdapter(options);
+}
+export {
+  Physics2dPredictor,
+  createMatterAdapter
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/client",
-  "version": "0.5.2",
+  "version": "0.7.0",
   "description": "irtio client SDK: joinRoom, owned-write batching, corrections, typed RPCs, presence, reconnection",
   "license": "MIT",
   "publishConfig": {
@@ -19,22 +19,31 @@
     "dist"
   ],
   "dependencies": {
-    "@irtio/schema": "0.5.2",
-    "@irtio/protocol": "0.5.2"
+    "mediasoup-client": "^3.23.1",
+    "@irtio/protocol": "0.7.0",
+    "@irtio/schema": "0.7.0"
   },
   "peerDependencies": {
-    "@dimforge/rapier3d-compat": ">=0.20.0"
+    "@dimforge/rapier3d-compat": ">=0.20.0",
+    "matter-js": ">=0.20.0"
   },
   "peerDependenciesMeta": {
     "@dimforge/rapier3d-compat": {
       "optional": true
+    },
+    "matter-js": {
+      "optional": true
     }
   },
   "devDependencies": {
-    "@dimforge/rapier3d-compat": "0.20.0"
+    "@dimforge/rapier3d-compat": "0.20.0",
+    "@types/matter-js": "0.20.2",
+    "matter-js": "0.20.0",
+    "@irtio/sfu": "0.0.0"
   },
   "scripts": {
     "build": "tsup",
-    "test": "vitest run"
+    "test": "vitest run",
+    "test:browser": "playwright test"
   }
 }