@driftengine/physics 3.62.0 → 4.0.0

package/NOTICE

@@ -7,3 +7,23 @@ This product includes software developed at Drift Technologies
 Licensed under the Apache License, Version 2.0. Section 4(d) of that licence
 requires this NOTICE to be reproduced in any derivative work you distribute,
 in the source, the documentation, or a display generated by the work.
+
+Models run by DriftCapture
+--------------------------
+DriftCapture runs the models below. Their weights are not in this repository
+and are not distributed with it: tools/capture-weights/ fetches each at the
+revision its manifest pins, verifies it, and converts it, and a game that
+ships one ships it under that model's own licence. Each model's definition in
+this engine is written from its project's published code.
+
+- Depth Anything 3 Small and Depth Anything 3 Base. Apache License 2.0.
+  Copyright (c) 2025 ByteDance Ltd. and/or its affiliates.
+- Depth Anything V2 Small. Apache License 2.0. The University of Hong Kong
+  and TikTok; converted to the Transformers layout by The HuggingFace Team.
+- MobileSAM. Apache License 2.0. Its image encoder is TinyViT, Copyright (c)
+  2022 Microsoft; its prompt encoder and mask decoder are Segment Anything's,
+  Copyright (c) Meta Platforms, Inc. and affiliates.
+- SAM 2.1 tiny. Apache License 2.0. Copyright (c) Meta Platforms, Inc. and
+  affiliates.
+- OWLv2 base patch16. Apache License 2.0. Copyright 2023 Google AI and The
+  HuggingFace Team.

package/README.md

@@ -5,7 +5,7 @@ kinematic sweep that resolves a moving body against a static world one axis at a
 
 **It imports no other engine package.** Together with `@driftengine/entities` that makes a
 deterministic simulation you can run with no renderer in its module graph — in Node, in a worker,
-or on a server, which is what an authoritative host needs. **45.0 KB gzipped** standalone, measured
+or on a server, which is what an authoritative host needs. **45.1 KB gzipped** standalone, measured
 by `scripts/size-gate.test.mjs` against `scripts/fixtures/size/physics-only.ts`.
 
 **`@driftengine/core` re-exports every name here**, so reaching for collision through the core

package/dist/query.js

@@ -21,6 +21,36 @@ const manifold = createManifold();
  * The full set is `PhysicsWorld`'s business, where every plane becomes a constraint.
  */
 const MESH_ONE = [createManifold()];
+/**
+ * Manifolds a sweep against a mesh gathers before it decides how far it may advance.
+ *
+ * **Which triangle stopped a sweep is not a question one manifold can answer.** `collideMesh` fills
+ * its output in the order the tree hands triangles over, and the sweep read one of them — so near a
+ * crease, where a wall meets a floor, a downward sweep was answered with the wall's horizontal
+ * normal and nothing stopped the fall. Found by the first test of `CharacterController` against a
+ * triangle mesh: a capsule on a captured room's floor sank straight through it, while the same
+ * floor **on its own** held it, because adding the walls changed which triangle came back first.
+ * Sixteen is far more than a sweep meets at once, and the one facing back along the travel is the
+ * one in the way.
+ */
+const MESH_SET = [
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+    createManifold(),
+];
 function copyManifold(from, to) {
     to.nx = from.nx;
     to.ny = from.ny;
@@ -626,12 +656,44 @@ export function shapecastWorld(bodies, tree, shape, pose, dx, dy, dz, out, filte
              * since a step short of the true one converges rather than missing.
              */
             if (isMesh(shape) || isMesh(other)) {
-                if (collideMesh(shape, poseA, other, poseB, 1e9, MESH_ONE) === 0)
+                /*
+                 * **Asked for within the travel that is left, not within everything.** The margin inflates
+                 * the tree query's box, so a margin of a billion metres makes every triangle of the mesh a
+                 * candidate — which is both the whole mesh's cost per step and the reason the set that came
+                 * back was arbitrary. Nothing further away than the sweep can reach can stop it.
+                 */
+                const reach = travel * (1 - t) + 1e-4;
+                const met = collideMesh(shape, poseA, other, poseB, reach, MESH_SET);
+                if (met === 0)
                     break;
-                const first = MESH_ONE[0];
-                if (first === undefined)
+                /*
+                 * **Two different questions, and one manifold cannot answer both.** How far the sweep may
+                 * advance is bounded by the *nearest* surface, whichever way it faces. Which surface
+                 * *stopped* it is the nearest one facing back along the travel — and near a crease, where a
+                 * wall meets a floor, those are not the same triangle. Answering the first for both is what
+                 * made a capsule walking at a captured step sink through the floor: the wall beside it was
+                 * always the nearer contact, so every downward sweep reported a horizontal normal and
+                 * nothing ever stopped the fall. On box bodies, which have one manifold, the same walk is
+                 * fine — which is why this only ever showed on a mesh.
+                 */
+                let blocking = -1;
+                let into = 1e-9;
+                for (let m = 0; m < met; m++) {
+                    const held = MESH_SET[m];
+                    if (held === undefined)
+                        continue;
+                    if ((held.separations[0] ?? 0) >= 1e-4)
+                        continue;
+                    const opposes = dx * held.nx + dy * held.ny + dz * held.nz;
+                    if (opposes > into) {
+                        into = opposes;
+                        blocking = m;
+                    }
+                }
+                const chosen = MESH_SET[blocking >= 0 ? blocking : 0];
+                if (chosen === undefined)
                     break;
-                copyManifold(first, manifold);
+                copyManifold(chosen, manifold);
             }
             else if (!collideShapes(shape, poseA, other, poseB, 1e9, manifold))
                 break;

package/dist/workerPool.js

@@ -107,9 +107,13 @@ export function createIslandPool(request) {
  * A build that does not throws, which becomes a reason and serial physics — and `spawn` is the way
  * out, which is why this is a default and not the only path. Null where there is no `Worker` at all.
  */
-const defaultSpawn = typeof Worker === 'undefined'
+const defaultSpawn = 
+// platform: feature probe — no `Worker` means serial physics, with a reason
+typeof Worker === 'undefined'
     ? null
-    : () => new Worker(new URL('./islandWorker.ts', import.meta.url), { type: 'module' });
+    : () => 
+    // platform: browser default — `spawn` is the seam a native host supplies
+    new Worker(new URL('./islandWorker.js', import.meta.url), { type: 'module' });
 /**
  * The pool itself: `StagedExecutor` with the serial solve replaced by a fork and a join.
  *
@@ -184,12 +188,15 @@ export class WorkerPoolExecutor extends StagedExecutor {
     join() {
         const ctl = this.control;
         const wanted = this.workers.length;
-        const deadline = Date.now() + JOIN_DEADLINE_MS;
+        /* Monotonic, because this is a spin against a deadline and the wall clock moves. A backward
+           step means the deadline never arrives and the join spins until the tab is closed — which is
+           the exact failure the deadline above was added to prevent. */
+        const deadline = performance.now() + JOIN_DEADLINE_MS;
         for (;;) {
             const done = Atomics.load(ctl, CTL_DONE);
             if (done >= wanted)
                 return true;
-            if (Date.now() > deadline) {
+            if (performance.now() > deadline) {
                 this.failure =
                     'a worker stopped answering, so island solving went back to this thread. The world is ' +
                         'correct and serial from here.';
@@ -223,9 +230,9 @@ export class WorkerPoolExecutor extends StagedExecutor {
                 plan: stage.plan,
             });
         }
-        const deadline = Date.now() + JOIN_DEADLINE_MS;
+        const deadline = performance.now() + JOIN_DEADLINE_MS;
         while (Atomics.load(ctl, CTL_ACK) < this.workers.length) {
-            if (Date.now() > deadline) {
+            if (performance.now() > deadline) {
                 this.failure =
                     'the workers did not take the shared buffer, so island solving stayed on this thread.';
                 return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/physics",
-  "version": "3.62.0",
+  "version": "4.0.0",
   "description": "Collision shapes, spatial queries and swept kinematic collision",
   "license": "Apache-2.0",
   "type": "module",

package/src/query.ts

@@ -71,6 +71,37 @@ const manifold = createManifold();
  */
 const MESH_ONE = [createManifold()] as const;
 
+/**
+ * Manifolds a sweep against a mesh gathers before it decides how far it may advance.
+ *
+ * **Which triangle stopped a sweep is not a question one manifold can answer.** `collideMesh` fills
+ * its output in the order the tree hands triangles over, and the sweep read one of them — so near a
+ * crease, where a wall meets a floor, a downward sweep was answered with the wall's horizontal
+ * normal and nothing stopped the fall. Found by the first test of `CharacterController` against a
+ * triangle mesh: a capsule on a captured room's floor sank straight through it, while the same
+ * floor **on its own** held it, because adding the walls changed which triangle came back first.
+ * Sixteen is far more than a sweep meets at once, and the one facing back along the travel is the
+ * one in the way.
+ */
+const MESH_SET = [
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+  createManifold(),
+] as const;
+
 function copyManifold(from: typeof manifold, to: typeof manifold): void {
   to.nx = from.nx;
   to.ny = from.ny;
@@ -792,10 +823,40 @@ export function shapecastWorld(
        * since a step short of the true one converges rather than missing.
        */
       if (isMesh(shape) || isMesh(other)) {
-        if (collideMesh(shape, poseA, other, poseB, 1e9, MESH_ONE) === 0) break;
-        const first = MESH_ONE[0];
-        if (first === undefined) break;
-        copyManifold(first, manifold);
+        /*
+         * **Asked for within the travel that is left, not within everything.** The margin inflates
+         * the tree query's box, so a margin of a billion metres makes every triangle of the mesh a
+         * candidate — which is both the whole mesh's cost per step and the reason the set that came
+         * back was arbitrary. Nothing further away than the sweep can reach can stop it.
+         */
+        const reach = travel * (1 - t) + 1e-4;
+        const met = collideMesh(shape, poseA, other, poseB, reach, MESH_SET);
+        if (met === 0) break;
+        /*
+         * **Two different questions, and one manifold cannot answer both.** How far the sweep may
+         * advance is bounded by the *nearest* surface, whichever way it faces. Which surface
+         * *stopped* it is the nearest one facing back along the travel — and near a crease, where a
+         * wall meets a floor, those are not the same triangle. Answering the first for both is what
+         * made a capsule walking at a captured step sink through the floor: the wall beside it was
+         * always the nearer contact, so every downward sweep reported a horizontal normal and
+         * nothing ever stopped the fall. On box bodies, which have one manifold, the same walk is
+         * fine — which is why this only ever showed on a mesh.
+         */
+        let blocking = -1;
+        let into = 1e-9;
+        for (let m = 0; m < met; m++) {
+          const held = MESH_SET[m];
+          if (held === undefined) continue;
+          if ((held.separations[0] ?? 0) >= 1e-4) continue;
+          const opposes = dx * held.nx + dy * held.ny + dz * held.nz;
+          if (opposes > into) {
+            into = opposes;
+            blocking = m;
+          }
+        }
+        const chosen = MESH_SET[blocking >= 0 ? blocking : 0];
+        if (chosen === undefined) break;
+        copyManifold(chosen, manifold);
       } else if (!collideShapes(shape, poseA, other, poseB, 1e9, manifold)) break;
       const gap = manifold.separations[0] ?? 0;
       if (gap < 1e-4) {

package/src/workerPool.ts

@@ -141,9 +141,11 @@ export function createIslandPool(request: PoolRequest): PoolOutcome {
  * out, which is why this is a default and not the only path. Null where there is no `Worker` at all.
  */
 const defaultSpawn: (() => PoolWorker) | null =
+  // platform: feature probe — no `Worker` means serial physics, with a reason
   typeof Worker === 'undefined'
     ? null
     : (): PoolWorker =>
+        // platform: browser default — `spawn` is the seam a native host supplies
         new Worker(new URL('./islandWorker.ts', import.meta.url), { type: 'module' }) as PoolWorker;
 
 /**
@@ -227,11 +229,14 @@ export class WorkerPoolExecutor extends StagedExecutor implements Executor {
   private join(): boolean {
     const ctl = this.control;
     const wanted = this.workers.length;
-    const deadline = Date.now() + JOIN_DEADLINE_MS;
+    /* Monotonic, because this is a spin against a deadline and the wall clock moves. A backward
+       step means the deadline never arrives and the join spins until the tab is closed — which is
+       the exact failure the deadline above was added to prevent. */
+    const deadline = performance.now() + JOIN_DEADLINE_MS;
     for (;;) {
       const done = Atomics.load(ctl, CTL_DONE);
       if (done >= wanted) return true;
-      if (Date.now() > deadline) {
+      if (performance.now() > deadline) {
         this.failure =
           'a worker stopped answering, so island solving went back to this thread. The world is ' +
           'correct and serial from here.';
@@ -267,9 +272,9 @@ export class WorkerPoolExecutor extends StagedExecutor implements Executor {
       });
     }
 
-    const deadline = Date.now() + JOIN_DEADLINE_MS;
+    const deadline = performance.now() + JOIN_DEADLINE_MS;
     while (Atomics.load(ctl, CTL_ACK) < this.workers.length) {
-      if (Date.now() > deadline) {
+      if (performance.now() > deadline) {
         this.failure =
           'the workers did not take the shared buffer, so island solving stayed on this thread.';
         return false;