@adatechnology/game-floorplan-three 0.7.0 → 0.8.0

package/dist/index.js

@@ -6236,6 +6236,10 @@ function installDestructionPieces(K, shared) {
 function collapseRange(mesh, v0, v1) {
   const pos = mesh.geometry.attributes.position;
   const a = pos.array;
+  const u = mesh.userData;
+  if (!u._p0) u._p0 = a.slice();
+  const list = u.collapsedRanges ?? (u.collapsedRanges = []);
+  if (!list.some((r) => r[0] === v0 && r[1] === v1)) list.push([v0, v1]);
   const saved = a.slice(v0 * 3, v1 * 3);
   const x = a[v0 * 3], y = a[v0 * 3 + 1], z = a[v0 * 3 + 2];
   for (let k = v0; k < v1; k++) {
@@ -6250,6 +6254,8 @@ function restoreRange(mesh, v0, saved) {
   const pos = mesh.geometry.attributes.position;
   pos.array.set(saved, v0 * 3);
   pos.needsUpdate = true;
+  const list = mesh.userData.collapsedRanges;
+  if (list) mesh.userData.collapsedRanges = list.filter((r) => r[0] !== v0);
 }
 function noise2(x, y, cell) {
   const h = (i2, j2) => {
@@ -6264,13 +6270,16 @@ var MASK_TEXEL = 0.02;
 var SPALL_MIN = 0.025;
 var SPALL_RAGGED = 0.045;
 var COVER = 0.015;
+var MAX_FLAKES = 64;
 function installDestructionBreach(K, _shared) {
   const { THREE, fragmentMaterial, invalidate, invalidateShadow } = K;
   function createBreachView(opts) {
     const { house, structure } = opts;
     const views = /* @__PURE__ */ new Map();
+    const dirty = /* @__PURE__ */ new Set();
+    const paintBudgetMs = opts.paintBudgetMs ?? Infinity;
+    const dropped = [];
     let lod = 0;
-    const unitMaterial = new THREE.MeshLambertMaterial({ color: 16777215 });
     const unitGeometry = new THREE.BoxGeometry(1, 1, 1);
     const tmp = { m: new THREE.Matrix4(), q: new THREE.Quaternion(), p: new THREE.Vector3(), s: new THREE.Vector3(), c: new THREE.Color() };
     const local = (p) => {
@@ -6339,6 +6348,11 @@ function installDestructionBreach(K, _shared) {
       const mesh = new THREE.Mesh(g, material);
       mesh.name = "breach-shell";
       mesh.userData.breachMask = mask;
+      mesh.userData.cutAt = (p) => {
+        const v = local([p.x, p.y, p.z]);
+        const i = Math.floor(((mask.alongU ? v[0] : v[2]) - mask.start) / mask.len * mask.w), j = Math.floor((v[1] - mask.y0) / mask.height * mask.h);
+        return i >= 0 && i < mask.w && j >= 0 && j < mask.h && mask.data[j * mask.w + i] > 127;
+      };
       mesh.position.copy(it.mesh.position);
       mesh.quaternion.copy(it.mesh.quaternion);
       mesh.scale.copy(it.mesh.scale);
@@ -6354,6 +6368,19 @@ function installDestructionBreach(K, _shared) {
       toHouse.value.copy(house.matrixWorld).invert().multiply(mesh.matrixWorld);
       return mesh;
     }
+    function unitsMaterial(core) {
+      const material = new THREE.MeshLambertMaterial({ color: 16777215, side: THREE.DoubleSide });
+      material.onBeforeCompile = (sh) => {
+        sh.uniforms.uCore = { value: core.texture };
+        sh.uniforms.uCoreRect = { value: core.rect };
+        sh.uniforms.uCoreAlongX = { value: core.alongU ? 1 : 0 };
+        sh.vertexShader = sh.vertexShader.replace("void main() {", "varying vec3 vHousePos;\nvoid main() {").replace("#include <begin_vertex>", "#include <begin_vertex>\n#ifdef USE_INSTANCING\nvHousePos = (instanceMatrix * vec4(transformed, 1.0)).xyz;\n#else\nvHousePos = transformed;\n#endif");
+        sh.fragmentShader = sh.fragmentShader.replace("void main() {", "uniform sampler2D uCore;\nuniform vec4 uCoreRect;\nuniform float uCoreAlongX;\nvarying vec3 vHousePos;\nvoid main() {\n  vec2 cUv = vec2(((uCoreAlongX > 0.5 ? vHousePos.x : vHousePos.z) - uCoreRect.x) / uCoreRect.z, (vHousePos.y - uCoreRect.y) / uCoreRect.w);\n  if (cUv.x >= 0.0 && cUv.x <= 1.0 && cUv.y >= 0.0 && cUv.y <= 1.0 && texture2D(uCore, cUv).r > 0.5) discard;").replace("#include <color_fragment>", "#include <color_fragment>\nif (!gl_FrontFacing) diffuseColor.rgb *= 0.55;");
+      };
+      material.customProgramCacheKey = () => "breachCore";
+      material.userData.breachCore = core;
+      return material;
+    }
     function maskOf(hostId, parts) {
       const host = structure.byId.get(hostId);
       const [u0, v0, u1, v1] = host.aabb;
@@ -6369,41 +6396,73 @@ function installDestructionBreach(K, _shared) {
       return { data, texture, w, h, alongU, start: alongU ? u0 : v0, len, y0, height: y1 - y0, rect: new THREE.Vector4(alongU ? u0 : v0, y0, len, y1 - y0) };
     }
     const boxDistance = (s, y, a, b, c, d) => Math.hypot(Math.max(a - s, 0, s - b), Math.max(c - y, 0, y - d));
+    const ellipseDistance = (s, y, cs, cy, rs, ry) => (Math.hypot((s - cs) / Math.max(rs, 1e-4), (y - cy) / Math.max(ry, 1e-4)) - 1) * Math.min(rs, ry);
+    function covered(c, boxes) {
+      const n = 8;
+      let hit = 0;
+      for (let j = 0; j < n; j++) {
+        const y = c.y0 + (j + 0.5) / n * (c.y1 - c.y0);
+        for (let i = 0; i < n; i++) {
+          const s = c.a + (i + 0.5) / n * (c.b - c.a);
+          if (boxes.some((k) => s >= k.s0 && s <= k.s1 && y >= k.y0 && y <= k.y1)) hit++;
+        }
+      }
+      return hit / (n * n);
+    }
     function paint(view) {
-      const { mask } = view;
+      const { mask, core } = view;
       const along = (p) => (mask.alongU ? p[0] : p[2]) - mask.start;
       const holes = [];
+      const pits = [];
       const discs = [];
+      const flakes = [];
       const shown = [];
       for (const id of view.parts) {
-        const part = structure.byId.get(id), units2 = specOf(id).units, chips = view.chips.get(id), opening = view.openings.get(id);
+        const part = structure.byId.get(id), units2 = specOf(id).units, chips = view.chips.get(id), opening = view.openings.get(id), spalls = view.spalls.get(id);
         const all = cells(part, units2);
         const thick = mask.alongU ? part.aabb[3] - part.aabb[1] : part.aabb[2] - part.aabb[0];
         const mid = mask.alongU ? (part.aabb[1] + part.aabb[3]) / 2 : (part.aabb[0] + part.aabb[2]) / 2;
         if (opening) discs.push({ s: along(opening.center), y: opening.center[1], r: opening.radius });
-        const gone = (c) => chips.some((p) => p[1] >= c.y0 && p[1] <= c.y1 && along(p) >= c.a && along(p) <= c.b) || opening && Math.hypot((c.a + c.b) / 2 - along(opening.center), (c.y0 + c.y1) / 2 - opening.center[1]) < opening.radius;
+        for (const k of spalls) flakes.push({ s: along(k.center), y: k.center[1], r: k.radius });
+        const boxes = chips.map((k) => ({ s0: along(k.center) - k.along, s1: along(k.center) + k.along, y0: k.center[1] - k.up, y1: k.center[1] + k.up }));
+        const gone = (c) => covered(c, boxes.filter((k) => k.s1 > c.a && k.s0 < c.b && k.y1 > c.y0 && k.y0 < c.y1)) >= 0.9 || opening && Math.hypot((c.a + c.b) / 2 - along(opening.center), (c.y0 + c.y1) / 2 - opening.center[1]) < opening.radius;
         const kept = [];
         for (const c of all) (gone(c) ? holes : kept).push(c);
         for (const c of kept) shown.push({ c, part, units: units2, thick, mid });
+        for (const k of boxes) {
+          if (holes.some((h) => k.s0 >= h.a - 1e-4 && k.s1 <= h.b + 1e-4 && k.y0 >= h.y0 - 1e-4 && k.y1 <= h.y1 + 1e-4)) continue;
+          pits.push({ s: (k.s0 + k.s1) / 2, y: (k.y0 + k.y1) / 2, rs: (k.s1 - k.s0) / 2, ry: (k.y1 - k.y0) / 2 });
+        }
       }
       const reach = SPALL_MIN + SPALL_RAGGED;
+      const ragged = (s, y) => 0.6 * noise2(s, y, 0.03) + 0.4 * noise2(s + 7.3, y - 3.1, 0.011);
       mask.data.fill(0);
-      const stamp = (s0, s1, y0, y1, inside) => {
-        const i0 = Math.max(0, Math.floor((s0 - reach) / mask.len * mask.w)), i1 = Math.min(mask.w - 1, Math.ceil((s1 + reach) / mask.len * mask.w));
-        const j0 = Math.max(0, Math.floor((y0 - reach - mask.y0) / mask.height * mask.h)), j1 = Math.min(mask.h - 1, Math.ceil((y1 + reach - mask.y0) / mask.height * mask.h));
+      core.data.fill(0);
+      const stamp = (m, s0, s1, y0, y1, inside) => {
+        const i0 = Math.max(0, Math.floor((s0 - reach) / m.len * m.w)), i1 = Math.min(m.w - 1, Math.ceil((s1 + reach) / m.len * m.w));
+        const j0 = Math.max(0, Math.floor((y0 - reach - m.y0) / m.height * m.h)), j1 = Math.min(m.h - 1, Math.ceil((y1 + reach - m.y0) / m.height * m.h));
         for (let j = j0; j <= j1; j++) {
-          const y = mask.y0 + (j + 0.5) / mask.h * mask.height;
+          const y = m.y0 + (j + 0.5) / m.h * m.height;
           for (let i = i0; i <= i1; i++) {
-            const s = (i + 0.5) / mask.w * mask.len;
-            const edge = SPALL_MIN + SPALL_RAGGED * (0.6 * noise2(s, y, 0.03) + 0.4 * noise2(s + 7.3, y - 3.1, 0.011));
-            if (inside(s, y) <= edge) mask.data[j * mask.w + i] = 255;
+            const s = (i + 0.5) / m.w * m.len;
+            if (inside(s, y)) m.data[j * m.w + i] = 255;
           }
         }
       };
-      for (const c of holes) stamp(c.a, c.b, c.y0, c.y1, (s, y) => boxDistance(s, y, c.a, c.b, c.y0, c.y1));
-      for (const d of discs) stamp(d.s - d.r, d.s + d.r, d.y - d.r, d.y + d.r, (s, y) => Math.max(0, Math.hypot(s - d.s, y - d.y) - d.r));
+      const plaster = (d, s, y) => d <= SPALL_MIN + SPALL_RAGGED * ragged(s, y);
+      for (const c of holes) stamp(mask, c.a, c.b, c.y0, c.y1, (s, y) => plaster(boxDistance(s, y, c.a, c.b, c.y0, c.y1), s, y));
+      for (const d of discs) stamp(mask, d.s - d.r, d.s + d.r, d.y - d.r, d.y + d.r, (s, y) => plaster(Math.max(0, Math.hypot(s - d.s, y - d.y) - d.r), s, y));
+      for (const f of flakes) {
+        const rough = (s, y) => Math.hypot(s - f.s, y - f.y) - f.r * (0.65 + 0.7 * ragged(s * 2.3, y * 2.3));
+        stamp(mask, f.s - 2 * f.r, f.s + 2 * f.r, f.y - 2 * f.r, f.y + 2 * f.r, (s, y) => rough(s, y) <= 0);
+      }
+      for (const p of pits) {
+        stamp(mask, p.s - p.rs, p.s + p.rs, p.y - p.ry, p.y + p.ry, (s, y) => plaster(Math.max(0, ellipseDistance(s, y, p.s, p.y, p.rs, p.ry)), s, y));
+        stamp(core, p.s - p.rs, p.s + p.rs, p.y - p.ry, p.y + p.ry, (s, y) => ellipseDistance(s, y, p.s, p.y, p.rs, p.ry) <= -0.35 * Math.min(p.rs, p.ry) * noise2(s * 1.7, y * 1.3, 0.012));
+      }
       mask.texture.needsUpdate = true;
-      const near = (c) => holes.some((h) => boxDistance((c.a + c.b) / 2, (c.y0 + c.y1) / 2, h.a - (c.b - c.a) / 2, h.b + (c.b - c.a) / 2, h.y0 - (c.y1 - c.y0) / 2, h.y1 + (c.y1 - c.y0) / 2) <= reach) || discs.some((d) => boxDistance(d.s, d.y, c.a, c.b, c.y0, c.y1) <= d.r + reach);
+      core.texture.needsUpdate = true;
+      const near = (c) => holes.some((h) => boxDistance((c.a + c.b) / 2, (c.y0 + c.y1) / 2, h.a - (c.b - c.a) / 2, h.b + (c.b - c.a) / 2, h.y0 - (c.y1 - c.y0) / 2, h.y1 + (c.y1 - c.y0) / 2) <= reach) || discs.some((d) => boxDistance(d.s, d.y, c.a, c.b, c.y0, c.y1) <= d.r + reach) || pits.some((p) => boxDistance(p.s, p.y, c.a, c.b, c.y0, c.y1) <= Math.max(p.rs, p.ry) + reach) || flakes.some((f) => boxDistance(f.s, f.y, c.a, c.b, c.y0, c.y1) <= 2 * f.r);
       const list = [];
       const tone = (hex, k) => tmp.c.setHex(hex).multiplyScalar(k).getHex();
       for (const { c, part, units: units2, thick, mid } of shown) {
@@ -6413,7 +6472,7 @@ function installDestructionBreach(K, _shared) {
         const base = fragmentMaterial(part.material).color.getHex();
         const n = noise2(centre * 3.1, y * 2.7, 0.07);
         if (units2.mortar === "concrete") {
-          at(len, h, thick - 2 * COVER - 0.03 * n, tone(base, 0.86 + 0.2 * n));
+          at(len, h, thick - 2 * COVER, tone(base, 0.9 + 0.04 * n));
         } else {
           at(len, h, thick - 2 * COVER - 0.012, 10327948);
           at(len - 0.012, h - 0.012, thick - 2 * COVER, tone(base, 0.8 + 0.35 * n));
@@ -6423,7 +6482,7 @@ function installDestructionBreach(K, _shared) {
         view.units.removeFromParent();
         view.units.dispose();
       }
-      const units = new THREE.InstancedMesh(unitGeometry, unitMaterial, Math.max(1, list.length));
+      const units = new THREE.InstancedMesh(unitGeometry, view.unitMaterial, Math.max(1, list.length));
       units.name = "breach:" + view.host;
       list.forEach((u, i) => {
         tmp.m.compose(tmp.p.set(u.x, u.y, u.z), tmp.q.identity(), tmp.s.set(u.sx, u.sy, u.sz));
@@ -6439,6 +6498,19 @@ function installDestructionBreach(K, _shared) {
       house.add(units);
       view.units = units;
       view.gone = holes.length;
+      view.pits = pits.length;
+      view.flakes = flakes.length;
+    }
+    function chipBox(chip, alongU) {
+      house.updateMatrixWorld(true);
+      const q = tmp.q.set(chip.rotation[0], chip.rotation[1], chip.rotation[2], chip.rotation[3]).premultiply(house.getWorldQuaternion(new THREE.Quaternion()).invert());
+      let a = 0, u = 0;
+      for (let k = 0; k < 3; k++) {
+        const axis = tmp.p.set(k === 0 ? 1 : 0, k === 1 ? 1 : 0, k === 2 ? 1 : 0).applyQuaternion(q);
+        a += Math.abs(alongU ? axis.x : axis.z) * chip.size[k] / 2;
+        u += Math.abs(axis.y) * chip.size[k] / 2;
+      }
+      return { center: local(chip.center), along: a, up: u };
     }
     function draw2(partId, change) {
       if (lod !== 0) return false;
@@ -6450,23 +6522,49 @@ function installDestructionBreach(K, _shared) {
         if (!items.length) return false;
         const parts = [hostId, ...riders(hostId)].filter((id) => structure.byId.get(id) && specOf(id)?.units);
         if (!parts.includes(partId)) return false;
-        const mask = maskOf(hostId, parts);
-        view = { host: hostId, parts, items, mask, shells: [], saved: null, units: null, gone: 0, chips: new Map(parts.map((id) => [id, []])), openings: /* @__PURE__ */ new Map() };
+        const mask = maskOf(hostId, parts), core = maskOf(hostId, parts);
+        view = {
+          host: hostId,
+          parts,
+          items,
+          mask,
+          core,
+          unitMaterial: unitsMaterial(core),
+          shells: [],
+          saved: null,
+          units: null,
+          gone: 0,
+          pits: 0,
+          chips: new Map(parts.map((id) => [id, []])),
+          spalls: new Map(parts.map((id) => [id, []])),
+          openings: /* @__PURE__ */ new Map(),
+          flakes: 0
+        };
       }
       if (!view.chips.has(partId)) return false;
       if (change.opening) {
         if (view.openings.has(partId)) return false;
         view.openings.set(partId, { center: local(change.opening.center), radius: change.opening.radius });
       }
-      if (change.chip) view.chips.get(partId).push(local(change.chip));
+      if (change.chip) view.chips.get(partId).push(chipBox(change.chip, view.mask.alongU));
+      if (change.spall) {
+        const list = view.spalls.get(partId);
+        list.push({ center: local(change.spall.center), radius: change.spall.radius });
+        if (list.length > MAX_FLAKES) list.shift();
+      }
       if (!view.saved) {
         view.shells = view.items.map((it) => shell(it, view.mask));
+        for (const m of view.shells) m.userData.behind = () => view.units;
         view.saved = view.items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
       }
-      paint(view);
       views.set(hostId, view);
-      invalidate();
-      invalidateShadow();
+      if (opts.deferPaint && change.spall) dirty.add(view);
+      else {
+        dirty.delete(view);
+        paint(view);
+        invalidate();
+        invalidateShadow();
+      }
       return true;
     }
     function plain(view, shown) {
@@ -6475,24 +6573,70 @@ function installDestructionBreach(K, _shared) {
         else s.data = collapseRange(s.it.mesh, s.v0, s.it.v1);
       }
     }
+    function flush(budgetMs = paintBudgetMs) {
+      if (dirty.size === 0) return 0;
+      const deadline = performance.now() + budgetMs;
+      for (const view of dirty) {
+        dirty.delete(view);
+        paint(view);
+        if (performance.now() >= deadline) break;
+      }
+      invalidate();
+      invalidateShadow();
+      return dirty.size;
+    }
     function dispose(view) {
-      view.units.removeFromParent();
-      view.units.dispose();
+      dirty.delete(view);
+      if (view.units) {
+        view.units.removeFromParent();
+        view.units.dispose();
+      }
+      view.unitMaterial.dispose();
       for (const m of view.shells) {
         m.removeFromParent();
         m.geometry.dispose();
         m.material.dispose();
       }
       view.mask.texture.dispose();
+      view.core.texture.dispose();
     }
     return {
       /** Handles a `stage` event of the house's object. Returns true when the wall was cut. */
       stage(event) {
         return event.stage === 2 && !!event.opening ? draw2(event.part, { opening: event.opening }) : false;
       },
-      /** Handles a `chip` event: the unit that came out leaves a hole in the wall where it was. Returns true when the wall was cut. */
+      /**
+       * Handles a `spall` of a wall of units: the coat comes off in a ragged patch and the units show under it, drawn by the house (the destruction
+       * renderer leaves its flat patch out on the meshes `claim` marked). Returns true when the wall was cut.
+       */
+      spall(event) {
+        const r = Math.sqrt(Math.max(0, event.area) / Math.PI);
+        return r > 0 ? draw2(event.part, { spall: { center: event.point, radius: r } }) : false;
+      },
+      /**
+       * Marks the meshes that draw a wall of units as drawing its spalls itself (`userData.drawnSpalls`, the part ids): the destruction renderer then
+       * throws the bits and leaves its patch out. Call it once the spec is known.
+       */
+      claim() {
+        var _a;
+        for (const q of opts.spec()?.parts ?? []) {
+          if (!q.units) continue;
+          const host = hostOf(q.id);
+          if (!host) continue;
+          for (const it of structure.meshesOf(host)) {
+            if (!it.mesh) continue;
+            const list = (_a = it.mesh.userData).drawnSpalls ?? (_a.drawnSpalls = []);
+            if (!list.includes(q.id)) list.push(q.id);
+          }
+        }
+      },
+      /**
+       * Handles a `chip` event: what came out (a unit, or a crater a shot broke through one) leaves a hole in the wall where it was; a `torn` chip (what a blow
+       * tore off a face) leaves the marks the renderer drew. Returns true when the wall was cut.
+       */
       chip(event) {
-        return draw2(event.part, { chip: event.center });
+        if (event.torn) return false;
+        return draw2(event.part, { chip: { center: event.center, size: event.size ?? [0, 0, 0], rotation: event.rotation ?? [0, 0, 0, 1] } });
       },
       /** The part broke or fell: its damage goes (the plain range stays collapsed, the renderer hides the part). */
       drop(partId) {
@@ -6500,9 +6644,11 @@ function installDestructionBreach(K, _shared) {
         if (!v) return;
         dispose(v);
         views.delete(partId);
+        if (v.saved) dropped.push(v);
       },
       /** LOD 0 draws the cut wall; LOD 1 and 2 give the wall its box back. */
       setLod(level) {
+        flush(Infinity);
         const was = lod;
         lod = level;
         if (was === 0 === (level === 0)) return;
@@ -6521,15 +6667,20 @@ function installDestructionBreach(K, _shared) {
           if (lod === 0) plain(v, true);
         }
         views.clear();
+        for (const v of dropped) plain(v, true);
+        dropped.length = 0;
       },
+      flush,
       /** The wall has damage drawn. */
       has(partId) {
         return views.has(partId);
       },
-      /** Walls with damage drawn, units out of them, and units laid bare at the edge of the cuts. */
-      statistics: () => ({
+      /** Walls with damage drawn, units out of them, craters shots broke through units that stay, and units laid bare at the edge of the cuts. */
+      statistics: () => (flush(Infinity), {
         walls: views.size,
         gone: [...views.values()].reduce((n, v) => n + v.gone, 0),
+        craters: [...views.values()].reduce((n, v) => n + v.pits, 0),
+        flakes: [...views.values()].reduce((n, v) => n + v.flakes, 0),
         units: [...views.values()].reduce((n, v) => n + v.units.count, 0)
       })
     };
@@ -6538,6 +6689,7 @@ function installDestructionBreach(K, _shared) {
 }
 
 // src/destruction/world.ts
+var FOLLOW_FLUSH_FALLBACK_MS = 100;
 function installDestructionWorld(K, shared) {
   const { THREE, cfg, invalidateShadow, invalidate, rngString, FRAGMENT_GEO, fragmentMaterial, createBreachView } = K;
   function createHouseDestruction(root, house, structure, parts, colliders, water) {
@@ -6546,7 +6698,7 @@ function installDestructionWorld(K, shared) {
     const R = cfg.destructionRenderer || null, listeners = /* @__PURE__ */ new Set();
     D.renderer = R;
     D.spec = null;
-    const breach = createBreachView({ house, structure, spec: () => D.spec });
+    const breach = createBreachView({ house, structure, spec: () => D.spec, deferPaint: true, ...cfg.breachPaintBudgetMs !== void 0 ? { paintBudgetMs: cfg.breachPaintBudgetMs } : {} });
     D.breach = breach;
     D.onEvent = (fn) => {
       listeners.add(fn);
@@ -6731,6 +6883,9 @@ function installDestructionWorld(K, shared) {
         case "chip":
           breach.chip(e);
           break;
+        case "spall":
+          breach.spall(e);
+          break;
         case "collapse":
           for (const id of e.parts) {
             breach.drop(id);
@@ -6772,7 +6927,8 @@ function installDestructionWorld(K, shared) {
       D.specOptions = specOptions || null;
       D.spec = structure.spec(specOptions);
       D.id = D.world.add(D.spec, { id: "house3d:" + ++shared.destructionSeq, position: [p.x, p.y, p.z], rotation: [q.x, q.y, q.z, q.w] });
-      if (R) R.bind(D.id, house, { parts: rangesOf() });
+      breach.claim();
+      if (R) R.bind(D.id, house, { parts: rangesOf(), onFrame: () => breach.flush() });
       off = D.world.on("*", handleEvent);
       D.active = true;
       return D;
@@ -6787,6 +6943,8 @@ function installDestructionWorld(K, shared) {
     };
     D.follow = (world, id, spec) => {
       D.spec = spec;
+      breach.claim();
+      let fallback = null;
       const offFollow = world.on("*", (e) => {
         if (e.object !== id) return;
         switch (e.type) {
@@ -6796,6 +6954,9 @@ function installDestructionWorld(K, shared) {
           case "chip":
             breach.chip(e);
             break;
+          case "spall":
+            breach.spall(e);
+            break;
           case "fracture":
             breach.drop(e.part);
             break;
@@ -6805,10 +6966,16 @@ function installDestructionWorld(K, shared) {
           default:
             break;
         }
+        if (!fallback && typeof setTimeout === "function") fallback = setTimeout(() => {
+          fallback = null;
+          breach.flush(Infinity);
+        }, FOLLOW_FLUSH_FALLBACK_MS);
       });
       return { restore: () => breach.restore(), dispose: () => {
         offFollow();
         breach.restore();
+      }, update: () => {
+        breach.flush();
       } };
     };
     D.piece = (id) => D.active ? D.world.part(D.id, id) : null;
@@ -6841,6 +7008,7 @@ function installDestructionWorld(K, shared) {
       return r;
     };
     D.animate = (dt) => {
+      breach.flush();
       if (R) return;
       let moved = false;
       for (const [id, list] of bodies) {
@@ -8307,6 +8475,7 @@ function createFloorplanTestModule(options = {}) {
       houseRenderer = create(THREE, {
         locale,
         lod: { interior: 10, hide: 40 },
+        breachPaintBudgetMs: 4,
         ...options.house,
         quality: settings.quality,
         ...options.world ? { destruction: options.world } : {},
@@ -8462,9 +8631,39 @@ function createFloorplanTestModule(options = {}) {
       host?.log(text.steps.no_door);
       return;
     }
-    p.house.interact(eyeOf(p));
+    const fo = target.target;
+    const reach = fo && host?.reachFor && fo.type === "swing" && fo.gs?.[0] && fo.handles?.[0] ? doorReach(p, fo) : null;
+    if (reach && host?.reachFor) {
+      host.reachFor({ ...reach, onGrip: () => void p.house.toggleDoor(fo) });
+    } else p.house.interact(eyeOf(p));
     host?.log(fill(text.steps.door, { text: String(target.text) }));
   };
+  const doorReach = (p, fo) => {
+    const g = fo.gs[0];
+    const pivot = fo.handles[0].pivot;
+    const at = (angle) => {
+      const c = Math.cos(angle);
+      const s = Math.sin(angle);
+      const v = new THREE.Vector3(pivot[0] * c + pivot[2] * s, pivot[1], -pivot[0] * s + pivot[2] * c).add(g.position);
+      return g.parent ? g.parent.localToWorld(v) : v;
+    };
+    const camera = host?.camera;
+    const eye = new THREE.Vector3(camera.position.x, 0, camera.position.z);
+    const flat = (v) => Math.hypot(v.x - eye.x, v.z - eye.z);
+    const closed = at(0);
+    const open = at(fo.rot);
+    const opening = !fo.open;
+    return {
+      handle: () => {
+        g.updateMatrixWorld(true);
+        return g.localToWorld(new THREE.Vector3(pivot[0], pivot[1], pivot[2])).toArray();
+      },
+      hinge: () => g.getWorldPosition(new THREE.Vector3()).toArray(),
+      seconds: fo.locked || fo.blockedFlag ? 0.6 : 0.55,
+      pull: opening ? flat(open) <= flat(closed) : flat(closed) <= flat(open),
+      locked: !!(fo.locked || fo.blockedFlag)
+    };
+  };
   const strike = () => {
     const world = options.world;
     if (!world || !host) return;