@adatechnology/game-destruction-three 0.15.4 → 0.16.0

package/dist/index.js

@@ -122,13 +122,154 @@ function mixHex(a, b, t) {
   return r << 16 | g << 8 | bl;
 }
 
+// src/fragment-shapes.ts
+var FRAGMENT_SHAPE_VARIANTS = 6;
+var SLIVER_STATIONS = 6;
+var SLIVER_FRAY = 0.3;
+var SLIVER_SECTION = [[0.5, 0.5], [0, 0.5], [-0.5, 0.5], [-0.5, -0.5], [0, -0.5], [0.5, -0.5]];
+var sliverWidth = (t) => t < 0.25 ? 0.6 + 1.6 * t : t > 0.5 ? Math.max(0, (1 - t) / 0.5) ** 0.85 : 1;
+var pushTriangle = (out, a, b, c) => {
+  out.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+};
+var faceted = (THREE, positions) => {
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+  geometry.computeVertexNormals();
+  return geometry;
+};
+function buildSliverGeometry(THREE, seed) {
+  const rnd = createRng(7e3 + seed);
+  const rings = [];
+  const bendY = (rnd() - 0.5) * 0.3;
+  const bendZ = (rnd() - 0.5) * 0.3;
+  for (let i = 0; i < SLIVER_STATIONS - 1; i++) {
+    const t = i / (SLIVER_STATIONS - 1);
+    const x = -0.5 + t + (i > 0 ? (rnd() - 0.5) * 0.08 : 0);
+    const width = sliverWidth(t);
+    const lift = Math.sin(t * Math.PI);
+    rings.push(SLIVER_SECTION.map(([y, z]) => {
+      const fray = 1 - SLIVER_FRAY + SLIVER_FRAY * 1.4 * rnd();
+      return [x, Math.max(-0.5, Math.min(0.5, y * width * fray + bendY * lift)), Math.max(-0.5, Math.min(0.5, z * width * fray + bendZ * lift))];
+    }));
+  }
+  const tip = [0.5, (rnd() - 0.5) * 0.5, (rnd() - 0.5) * 0.3];
+  const torn = [-0.5 + rnd() * 0.12, (rnd() - 0.5) * 0.2, (rnd() - 0.5) * 0.2];
+  const sides = SLIVER_SECTION.length;
+  const positions = [];
+  for (let k = 0; k < sides; k++) {
+    const next = (k + 1) % sides;
+    pushTriangle(positions, torn, rings[0][next], rings[0][k]);
+    for (let i = 0; i < rings.length - 1; i++) {
+      const a = rings[i][k], b = rings[i][next], c = rings[i + 1][next], d = rings[i + 1][k];
+      pushTriangle(positions, a, b, c);
+      pushTriangle(positions, a, c, d);
+    }
+    const last = rings[rings.length - 1];
+    pushTriangle(positions, last[k], last[next], tip);
+  }
+  return faceted(THREE, positions);
+}
+function buildLumpGeometry(THREE, seed) {
+  const rnd = createRng(8e3 + seed);
+  const base = new THREE.IcosahedronGeometry(0.5, 0);
+  const source = base.getAttribute("position");
+  const pushOf = /* @__PURE__ */ new Map();
+  const positions = [];
+  for (let i = 0; i < source.count; i++) {
+    const x = source.getX(i), y = source.getY(i), z = source.getZ(i);
+    const key = `${x.toFixed(3)},${y.toFixed(3)},${z.toFixed(3)}`;
+    let push = pushOf.get(key);
+    if (push === void 0) {
+      push = 0.6 + 0.55 * rnd();
+      pushOf.set(key, push);
+    }
+    positions.push(x * push, y * push, z * push);
+  }
+  base.dispose();
+  const extent = [0, 0, 0];
+  for (let i = 0; i < positions.length; i++) extent[i % 3] = Math.max(extent[i % 3], Math.abs(positions[i]));
+  for (let i = 0; i < positions.length; i++) positions[i] *= 0.5 / Math.max(extent[i % 3], 1e-3);
+  return faceted(THREE, positions);
+}
+var VENEER_EDGE = 11;
+function buildVeneerGeometry(THREE, seed) {
+  const rnd = createRng(9e3 + seed);
+  const shape = new THREE.Shape();
+  const outline = [];
+  const edge = (y, inward) => y - inward * (rnd() * 0.16 + (rnd() < 0.15 ? 0.12 : 0));
+  for (let i = 0; i <= VENEER_EDGE; i++) outline.push([-0.5 + i / VENEER_EDGE, edge(0.5, 1)]);
+  outline.push([0.5 - rnd() * 0.12, 0.2 * rnd()], [0.5, -0.1 + 0.2 * rnd()], [0.5 - rnd() * 0.12, -0.25 * rnd()]);
+  for (let i = VENEER_EDGE; i >= 0; i--) outline.push([-0.5 + i / VENEER_EDGE, edge(-0.5, -1)]);
+  outline.push([-0.5 + rnd() * 0.12, -0.2 * rnd()], [-0.5, 0.1 * rnd()], [-0.5 + rnd() * 0.12, 0.25 * rnd()]);
+  shape.moveTo(outline[0][0], outline[0][1]);
+  for (let i = 1; i < outline.length; i++) shape.lineTo(outline[i][0], outline[i][1]);
+  shape.closePath();
+  const geometry = new THREE.ExtrudeGeometry(shape, { depth: 1, bevelEnabled: false });
+  geometry.translate(0, 0, -0.5);
+  return geometry;
+}
+var TORN_END = 0.24;
+var TORN_STRANDS = [4, 7];
+var pushQuad = (out, quad) => {
+  pushTriangle(out, quad[0], quad[1], quad[2]);
+  pushTriangle(out, quad[0], quad[2], quad[3]);
+};
+var unevenCuts = (count, rnd) => {
+  const shares = Array.from({ length: count }, () => 0.35 + 1.65 * rnd());
+  const total = shares.reduce((sum, share) => sum + share, 0);
+  const cuts = [-0.5];
+  for (const share of shares) cuts.push(cuts[cuts.length - 1] + share / total);
+  cuts[cuts.length - 1] = 0.5;
+  return cuts;
+};
+function buildBrokenBoardGeometry(THREE, seed) {
+  const rnd = createRng(1e4 + seed);
+  const end = 0.5 - TORN_END;
+  const positions = [];
+  const lo = -0.5, hi = 0.5;
+  pushQuad(positions, [[lo, lo, hi], [end, lo, hi], [end, hi, hi], [lo, hi, hi]]);
+  pushQuad(positions, [[lo, hi, lo], [end, hi, lo], [end, lo, lo], [lo, lo, lo]]);
+  pushQuad(positions, [[lo, hi, hi], [end, hi, hi], [end, hi, lo], [lo, hi, lo]]);
+  pushQuad(positions, [[lo, lo, lo], [end, lo, lo], [end, lo, hi], [lo, lo, hi]]);
+  pushQuad(positions, [[lo, lo, lo], [lo, lo, hi], [lo, hi, hi], [lo, hi, lo]]);
+  const count = TORN_STRANDS[0] + Math.floor(rnd() * (TORN_STRANDS[1] - TORN_STRANDS[0] + 1));
+  const cuts = unevenCuts(count, rnd);
+  for (let k = 0; k < count; k++) {
+    const y0 = cuts[k], y1 = cuts[k + 1];
+    const length = TORN_END * (0.15 + 0.85 * rnd());
+    const midX = end + length * (0.35 + 0.3 * rnd());
+    const narrow = 0.55 + 0.35 * rnd();
+    const shiftY = (rnd() - 0.5) * (y1 - y0) * 0.6;
+    const shiftZ = (rnd() - 0.5) * 0.5;
+    const cy = (y0 + y1) / 2 + shiftY, hy = (y1 - y0) / 2 * narrow, hz = 0.5 * (0.4 + 0.5 * rnd());
+    const base = [[end, y0, lo], [end, y1, lo], [end, y1, hi], [end, y0, hi]];
+    const clampZ = (z) => Math.max(lo, Math.min(hi, z));
+    const mid = [[midX, cy - hy, clampZ(shiftZ - hz)], [midX, cy + hy, clampZ(shiftZ - hz)], [midX, cy + hy, clampZ(shiftZ + hz)], [midX, cy - hy, clampZ(shiftZ + hz)]];
+    const tip = [end + length, y0 + (y1 - y0) * rnd(), clampZ(shiftZ + (rnd() - 0.5) * 0.4)];
+    for (let i = 0; i < 4; i++) {
+      const next = (i + 1) % 4;
+      pushQuad(positions, [base[i], base[next], mid[next], mid[i]]);
+      pushTriangle(positions, mid[i], mid[next], tip);
+    }
+  }
+  return faceted(THREE, positions);
+}
+
 // src/fragments.ts
+var BUILDERS = {
+  sliver: buildSliverGeometry,
+  lump: buildLumpGeometry,
+  veneer: buildVeneerGeometry,
+  board: buildBrokenBoardGeometry
+};
 var SHEET_MAX = 4e-3;
 var SHEET_AIR = 2.5;
 var SHEET_SWAY = 3;
 var BIG_LENGTH = 0.2;
 var BIG_WIDTH = 0.03;
 var FRAGMENT_SEED = 1374496523;
+var SUPPORT_CHECKS = 32;
+var SUPPORT_GAP = 0.02;
 var SHARD_SHAPES = 6;
 var isBig = (size) => {
   const [, middle, longest] = [...size].sort((a, b) => a - b);
@@ -143,6 +284,7 @@ var FragmentSystem = class {
     /** The mesh box of a fragment before its scale. */
     __publicField(this, "unitBox", { min: { x: -0.5, y: -0.5, z: -0.5 }, max: { x: 0.5, y: 0.5, z: 0.5 } });
     __publicField(this, "shardGeos", []);
+    __publicField(this, "shapeGeos", /* @__PURE__ */ new Map());
     __publicField(this, "materials", /* @__PURE__ */ new Map());
     __publicField(this, "q");
     __publicField(this, "dq");
@@ -152,6 +294,7 @@ var FragmentSystem = class {
     __publicField(this, "rng", createRng(FRAGMENT_SEED));
     /** Count of `update` calls: what makes the fragments of one burst tell apart from older ones. */
     __publicField(this, "tick", 0);
+    __publicField(this, "supportTurn", 0);
     __publicField(this, "markGeometry", null);
     __publicField(this, "markMaterial", null);
     this.box = new THREE.BoxGeometry(1, 1, 1);
@@ -200,21 +343,54 @@ var FragmentSystem = class {
     }
     return g;
   }
+  sharedGeometry(shape, seed) {
+    const idx = seed % FRAGMENT_SHAPE_VARIANTS;
+    let variants = this.shapeGeos.get(shape);
+    if (!variants) {
+      variants = [];
+      this.shapeGeos.set(shape, variants);
+    }
+    let g = variants[idx];
+    if (!g) {
+      g = BUILDERS[shape](this.THREE, idx);
+      variants[idx] = g;
+    }
+    return g;
+  }
+  /**
+   * The geometry a fragment is drawn with: a splinter is a pointed, frayed sliver; MDF breaks in lumps, plywood peels in ragged veneer, the stub of a broken
+   * board ends in torn strands at +x; the rest are boxes.
+   */
+  geometryOf(f) {
+    const seed = hashString(f.id);
+    if (f.shape === "shard") return this.shardGeometry(seed);
+    if (f.shape === "splinter") return this.sharedGeometry("sliver", seed);
+    const form = this.o.formOf?.(f.material);
+    if (f.shape === "chunk" && form === "granules") return this.sharedGeometry("lump", seed);
+    if (f.shape === "scrap" && form === "plies") return this.sharedGeometry("veneer", seed);
+    if (f.shape === "slab" && (form === "slivers" || form === "plies")) return this.sharedGeometry("board", seed);
+    return this.box;
+  }
   markParts() {
     this.markGeometry ?? (this.markGeometry = new this.THREE.CircleGeometry(1, 10));
     this.markMaterial ?? (this.markMaterial = new this.THREE.MeshBasicMaterial({ color: 723465, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
     return { geometry: this.markGeometry, material: this.markMaterial };
   }
   /**
-   * Meshes, never put in a scene by this class, that draw every shared piece of a fragment once: the box, the six shards, the bullet-hole disc, and the opaque and
+   * Meshes, never put in a scene by this class, that draw every shared piece of a fragment once: the box, the six shards, the wood splinters, MDF lumps and plywood veneer, the bullet-hole disc, and the opaque and
    * glass materials. A host draws them at load so the first blast does not upload these buffers in the middle of a frame.
    */
   warmMeshes() {
     const opaque = this.materialFor("warm", 8421504, false);
     const glass2 = this.materialFor("warm", 8421504, true);
     const geometries = [this.box, ...Array.from({ length: SHARD_SHAPES }, (_, index) => this.shardGeometry(index))];
+    const wood = ["sliver", "lump", "veneer", "board"].flatMap((shape) => Array.from({ length: FRAGMENT_SHAPE_VARIANTS }, (_, index) => this.sharedGeometry(shape, index)));
     const { geometry, material } = this.markParts();
-    return [...geometries.flatMap((shared) => [new this.THREE.Mesh(shared, opaque), new this.THREE.Mesh(shared, glass2)]), new this.THREE.Mesh(geometry, material)];
+    return [
+      ...geometries.flatMap((shared) => [new this.THREE.Mesh(shared, opaque), new this.THREE.Mesh(shared, glass2)]),
+      ...wood.map((shared) => new this.THREE.Mesh(shared, opaque)),
+      new this.THREE.Mesh(geometry, material)
+    ];
   }
   /**
    * Bullet holes that stay on a fragment (`Fragment.marks`): dark discs that are children of its mesh, so they fall, spin and settle with it. The mesh is
@@ -239,7 +415,11 @@ var FragmentSystem = class {
    * bigger than the budget (every live fragment was made in this same frame) does not make the rest at all, so a blast never builds a thousand meshes only to fade them
    * out. Returns null when the fragment was not made.
    */
-  spawn(f, material, home, maxAllowed) {
+  /**
+   * Throws `f` into the scene, within `maxAllowed` live fragments (the oldest small ones make room first). A `lasting` fragment (a steel bar) is debris that
+   * stays: it has a body the player and the pieces run into, however thin it is, and it never fades.
+   */
+  spawn(f, material, home, maxAllowed, lasting = false) {
     if (this.list.length >= maxAllowed) {
       let alive = 0;
       let oldest;
@@ -256,7 +436,7 @@ var FragmentSystem = class {
         oldest.dying = true;
       }
     }
-    const geo = f.shape === "shard" ? this.shardGeometry(hashString(f.id)) : this.box;
+    const geo = this.geometryOf(f);
     const mesh = new this.THREE.Mesh(geo, material);
     mesh.position.set(f.center[0], f.center[1], f.center[2]);
     mesh.quaternion.set(f.rotation[0], f.rotation[1], f.rotation[2], f.rotation[3]).normalize();
@@ -284,9 +464,9 @@ var FragmentSystem = class {
       air: f.shape === "scrap" && sz[2] <= SHEET_MAX ? SHEET_AIR : 0,
       body: null,
       born: this.tick,
-      life: Math.max(0, typeof this.o.life === "function" ? this.o.life(f, home) : this.o.life)
+      life: lasting ? 0 : Math.max(0, typeof this.o.life === "function" ? this.o.life(f, home) : this.o.life)
     };
-    if (f.shape !== "shard" && isBig(f.size)) {
+    if (lasting || f.shape !== "shard" && isBig(f.size)) {
       live.body = {
         mass: f.mass,
         push: (x, z) => {
@@ -346,6 +526,7 @@ var FragmentSystem = class {
   }
   update(dt) {
     this.tick++;
+    this.wakeUnsupported();
     const g = this.o.gravity;
     for (let i = this.list.length - 1; i >= 0; i--) {
       const f = this.list[i];
@@ -370,6 +551,18 @@ var FragmentSystem = class {
       this.step(f, dt, g);
     }
   }
+  /** A few fragments asleep each update (`SUPPORT_CHECKS`, in turn) look at the ground under them again: one left over air falls. */
+  wakeUnsupported() {
+    const n = this.list.length;
+    for (let k = 0; k < Math.min(SUPPORT_CHECKS, n); k++) {
+      this.supportTurn = (this.supportTurn + 1) % n;
+      const f = this.list[this.supportTurn];
+      if (!f.asleep || f.dying) continue;
+      const e = this.m.makeRotationFromQuaternion(f.mesh.quaternion).elements;
+      const ext = Math.abs(e[1]) * f.half.x + Math.abs(e[5]) * f.half.y + Math.abs(e[9]) * f.half.z;
+      if (f.mesh.position.y - ext > this.o.groundAt(f.mesh.position.x, f.mesh.position.z) + SUPPORT_GAP) this.rouse(f);
+    }
+  }
   step(f, dt, g) {
     const mesh = f.mesh;
     f.vel.y -= g * dt;
@@ -477,6 +670,8 @@ var FragmentSystem = class {
     this.markMaterial?.dispose();
     for (const g of this.shardGeos) g?.dispose();
     this.shardGeos = [];
+    for (const variants of this.shapeGeos.values()) for (const g of variants) g?.dispose();
+    this.shapeGeos.clear();
     for (const m of this.materials.values()) m.dispose();
     this.materials.clear();
   }
@@ -586,6 +781,8 @@ var WARM_SLOTS = 8 + 12 * 7;
 var SOLVER_PASSES = 10;
 var SIDE_BOUNCE = 0.1;
 var EDGE_POINTS = [-0.75, -0.5, -0.25, 0, 0.25, 0.5, 0.75];
+var SUPPORT_CHECKS2 = 16;
+var SUPPORT_GAP2 = 0.02;
 var boxTopAt = (s, x, z) => {
   const e = s.e;
   const dx = x - s.c[0], dz = z - s.c[2];
@@ -618,6 +815,7 @@ var PieceSystem = class {
     __publicField(this, "m");
     __publicField(this, "ax");
     __publicField(this, "solids", []);
+    __publicField(this, "supportTurn", 0);
     this.p = new THREE.Vector3();
     this.q = new THREE.Quaternion();
     this.dq = new THREE.Quaternion();
@@ -777,6 +975,7 @@ var PieceSystem = class {
       const h = body.halfExtents;
       return { body, c: [c.x, c.y, c.z], e: [...new this.THREE.Matrix4().makeRotationFromQuaternion(body.root.quaternion).elements], half: h, r: Math.hypot(h[0], h[1], h[2]) };
     });
+    this.wakeUnsupported();
     for (const b of this.list) {
       if (b.held) {
         b.velocity = [0, 0, 0];
@@ -791,6 +990,33 @@ var PieceSystem = class {
     }
     this.separate(dt);
   }
+  /** A few sleeping pieces each update (`SUPPORT_CHECKS`, in turn) look under them again: one whose table broke, or whose shelf fell over, falls. */
+  wakeUnsupported() {
+    const n = this.list.length;
+    for (let k = 0; k < Math.min(SUPPORT_CHECKS2, n); k++) {
+      this.supportTurn = (this.supportTurn + 1) % n;
+      const b = this.list[this.supportTurn];
+      if (!b.sleeping || b.held || this.supported(b, false) || this.supported(b, true)) continue;
+      b.sleeping = false;
+      b.still = 0;
+      b.calmAt = null;
+    }
+  }
+  /**
+   * Whether a point of `b` (its corners, or with `edges` the points along its edges too) has the ground, a piece or a fixed top under it. Any point, not only the lowest:
+   * a book propped on a fallen case rests by a corner high on it while its lowest one hangs beside it.
+   */
+  supported(b, edges) {
+    const c = this.centerOf(b, this.p);
+    const e = this.m.makeRotationFromQuaternion(b.root.quaternion).elements;
+    for (const [sx, sy, sz] of this.samples(b, edges)) {
+      const y = c.y + e[1] * sx + e[5] * sy + e[9] * sz;
+      const x = c.x + e[0] * sx + e[4] * sy + e[8] * sz;
+      const z = c.z + e[2] * sx + e[6] * sy + e[10] * sz;
+      if (this.supportAt(b, x, y, z, STEP) >= y - SUPPORT_GAP2) return true;
+    }
+    return false;
+  }
   /** Where a corner of `self` at `(x, y, z)` lands: the ground, the top of another piece or of something fixed under it. */
   supportAt(self, x, y, z, step) {
     let top = this.o.groundAt(x, z);
@@ -1164,6 +1390,7 @@ var RebarCages = class {
   constructor(THREE, scene2, radius = 4e-3) {
     __publicField(this, "THREE", THREE);
     __publicField(this, "scene", scene2);
+    __publicField(this, "radius", radius);
     __publicField(this, "cages", /* @__PURE__ */ new Map());
     __publicField(this, "geometry");
     __publicField(this, "material");
@@ -1192,28 +1419,62 @@ var RebarCages = class {
   meshes() {
     return [...this.cages.values()];
   }
-  /** Draw `bars` (world space) as the cage of `key`; an empty list removes it. */
-  set(key, bars) {
+  /**
+   * Draw `bars` (world space) as the cage of `key`; an empty list removes it. The cage is a child of `holder` (the drawing of the part's object, the scene
+   * by default), so it goes where the part goes: a beam that comes down takes its bare bars with it.
+   */
+  set(key, bars, holder) {
     this.remove(key);
     if (bars.length === 0) return;
+    const parent = holder ?? this.scene;
+    parent.updateWorldMatrix(true, false);
+    const toParent = new this.THREE.Matrix4().copy(parent.matrixWorld).invert();
     const mesh = new this.THREE.InstancedMesh(this.geometry, this.material, bars.length);
     bars.forEach(([a, b], i) => {
       this.dir.set(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
       const length = this.dir.length();
       this.mid.set((a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2);
       this.q.setFromUnitVectors(this.up, length > 1e-9 ? this.dir.divideScalar(length) : this.up);
-      this.m.compose(this.mid, this.q, this.scale.set(1, Math.max(length, 1e-4), 1));
+      this.m.compose(this.mid, this.q, this.scale.set(1, Math.max(length, 1e-4), 1)).premultiply(toParent);
       mesh.setMatrixAt(i, this.m);
     });
     mesh.instanceMatrix.needsUpdate = true;
     mesh.castShadow = true;
-    this.scene.add(mesh);
+    mesh.name = "rebar-cage";
+    parent.add(mesh);
     this.cages.set(key, mesh);
   }
+  /** The cage of `from` now belongs to `to` (a part that left its object for one of its own) and hangs from `holder`, where it is in the world now. */
+  move(from, to, holder) {
+    const mesh = this.cages.get(from);
+    if (!mesh) return;
+    this.cages.delete(from);
+    this.remove(to);
+    holder.attach(mesh);
+    this.cages.set(to, mesh);
+  }
+  /** Takes the cage of `key` away and gives its bars, where they are in the world now: centre, turn (the bar along its y) and length. */
+  take(key) {
+    const mesh = this.cages.get(key);
+    if (!mesh) return [];
+    mesh.updateWorldMatrix(true, false);
+    const bars = [];
+    for (let i = 0; i < mesh.count; i++) {
+      mesh.getMatrixAt(i, this.m);
+      this.m.premultiply(mesh.matrixWorld).decompose(this.mid, this.q, this.scale);
+      bars.push({ center: [this.mid.x, this.mid.y, this.mid.z], rotation: [this.q.x, this.q.y, this.q.z, this.q.w], length: this.scale.y });
+    }
+    this.remove(key);
+    return bars;
+  }
+  /** Radius of the bars drawn, metres. */
+  get barRadius() {
+    return this.radius;
+  }
   remove(key) {
     const mesh = this.cages.get(key);
     if (!mesh) return;
-    this.scene.remove(mesh);
+    mesh.removeFromParent();
     mesh.dispose();
     this.cages.delete(key);
   }
@@ -1556,6 +1817,23 @@ var DecalKit = class {
   }
 };
 var tmpV = (THREE) => new THREE.Vector3();
+function plainPositions(mesh, v0, v1) {
+  const { collapsedRanges, plainPositions: plain } = mesh.userData;
+  if (!plain || !collapsedRanges?.some(([a, b]) => a < v1 && b > v0)) return null;
+  return plain;
+}
+function showCollapsedRanges(mesh) {
+  const data = mesh.userData;
+  const plain = data.plainPositions;
+  const position = mesh.geometry?.getAttribute(POS_ATTR);
+  if (!plain || !data.collapsedRanges?.length || !position) return;
+  const array = position.array;
+  for (const [v0, v1] of data.collapsedRanges) array.set(plain.subarray(v0 * 3, v1 * 3), v0 * 3);
+  data.collapsedRanges = [];
+  position.needsUpdate = true;
+  mesh.geometry.computeBoundingBox();
+  mesh.geometry.computeBoundingSphere();
+}
 var MIN_DENT_VERTICES = 10;
 var WIDEN_MARGIN = 1.1;
 var SKIN_FOLLOW = 0.85;
@@ -2321,7 +2599,7 @@ var Visuals = class {
       const a = src.getAttribute(name);
       if (a.isInterleavedBufferAttribute) continue;
       const size = a.itemSize;
-      const from = (name === POS_ATTR ? host.work : null) ?? a.array;
+      const from = (name === POS_ATTR ? plainPositions(host.mesh, v0, v1) ?? host.work : null) ?? a.array;
       const slice = from.slice(v0 * size, v1 * size);
       const Ctor = a.array.constructor;
       geo.setAttribute(name, new this.THREE.BufferAttribute(new Ctor(slice), size, a.normalized));
@@ -2479,11 +2757,29 @@ var Visuals = class {
 // src/renderer.ts
 var rendererCount = 0;
 var COLLAPSE_CLOUD_KG = 1e3;
+var REBAR_COLOR = 7628380;
+var STEEL_DENSITY = 7850;
 var CHIP_DECAL_EDGE = 0.05;
 var WOOD_RIM = 1.5;
 var IMPACT_TAGS = ["metal", "glass", "wood"];
 var GLOW_FROM_C = 430;
 var QUEUE_CAP = 4e3;
+var STRUCTURAL_EVENTS = /* @__PURE__ */ new Set([
+  "fracture",
+  "detach",
+  "collapse",
+  "settle",
+  "destroyed",
+  "expose",
+  "stage",
+  "hole",
+  "ignite",
+  "primed",
+  "extinguish",
+  "burnout",
+  "leak",
+  "explode"
+]);
 var MIN_FRAGMENTS_PER_SLICE = 8;
 var STATIC_REFRESH = 0.5;
 var STATIC_REFRESH_SLICE_MS = 1;
@@ -2592,6 +2888,8 @@ var Renderer = class {
     __publicField(this, "pieceBoxes", /* @__PURE__ */ new WeakMap());
     __publicField(this, "staticAt", 0);
     __publicField(this, "queue", []);
+    /** The cover of each body around a part of the world that went off, read as the event is emitted: before the blast tore or moved anything. */
+    __publicField(this, "coverWhenWentOff", /* @__PURE__ */ new WeakMap());
     /** Presentation work an event left for later frames (fragments still to spawn, loose groups still to split), run in order within the frame budget. */
     __publicField(this, "slices", []);
     /** When the work of this frame must stop; `Infinity` outside a drain, where a call finishes what it started. */
@@ -2671,7 +2969,8 @@ var Renderer = class {
       groundAt: this.groundAt,
       gravity: this.gravity,
       max: this.maxFragments,
-      life: o.fragmentLife ?? 12
+      life: o.fragmentLife ?? 12,
+      formOf: (id) => this.world.materials.get(id)?.splitForm
     });
     this.cages = new RebarCages(THREE, o.scene);
     this.pieceSys = new PieceSystem(THREE, {
@@ -2684,7 +2983,8 @@ var Renderer = class {
       onSlam: (p, hit, speed) => this.slam(p, hit, speed)
     });
     this.unsubscribe = this.world.on("*", (ev) => {
-      if (this.queue.length < QUEUE_CAP) this.queue.push(ev);
+      if (ev.type === "explode") this.coverWhenWentOff.set(ev, this.coverAround(ev));
+      if (this.queue.length < QUEUE_CAP || STRUCTURAL_EVENTS.has(ev.type)) this.queue.push(ev);
     });
   }
   // ----------------------------------------------------------------------------------------------------------------------------------
@@ -3207,7 +3507,8 @@ var Renderer = class {
         this.onChip(ev);
         break;
       case "expose":
-        this.cages.set(`${ev.object}|${ev.part}`, ev.bars);
+        if (ev.bars.length > 0) this.cages.set(`${ev.object}|${ev.part}`, ev.bars, this.bounds.get(ev.object)?.root);
+        else this.dropCage(ev.object, ev.part);
         if (ev.bars.length > 0) {
           const [a, b] = ev.bars[0];
           this.playEvent({ kind: "expose" }, [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2]);
@@ -3505,7 +3806,7 @@ var Renderer = class {
     const rotation = new T.Quaternion(ev.rotation[0], ev.rotation[1], ev.rotation[2], ev.rotation[3]);
     for (const part of this.bounds.get(ev.object)?.parts.values() ?? []) for (const mv of part.meshes) this.visuals.clearDecals(mv, center, half, rotation);
     this.vfx.peekWorkshop()?.decals.clearInside(ev.center, [half.x, half.y, half.z], ev.rotation);
-    this.vfx.burst("dust", ev.center, [0, 1, 0], 8, 0.8, { color });
+    this.vfx.burst("dust", ev.center, [0, 1, 0], ev.units ? Math.min(40, 8 + ev.units.length) : 8, ev.units ? 1.6 : 0.8, { color });
     this.impactSound(pv?.material ?? "", ev.center, 0.7, ev.blow);
   }
   onFracture(ev) {
@@ -3524,6 +3825,7 @@ var Renderer = class {
       this.visuals.hide(pv, "broken");
     }
     this.spawnFragments(ev, 0, { def, color, opacity, transparent });
+    this.loosenIfFootless(ev.object);
     const up = [0, 1, 0];
     const sizeK = clamp(ev.fragments.length / 10, 0.5, 2);
     switch (ev.style) {
@@ -3569,6 +3871,33 @@ var Renderer = class {
     this.sound("detach", this.rootPoint(ev.object), 0.5);
     this.splitLoose(ev.object);
   }
+  /**
+   * The cage of a part gave way (`expose` with no bars): nothing holds its bars any more, so each comes down where it is, as steel debris that stays on the
+   * ground with a body (`FragmentSystem.spawn` with `lasting`), not as bars left standing in the air.
+   */
+  dropCage(objectId, partId) {
+    const bars = this.cages.take(`${objectId}|${partId}`);
+    if (bars.length === 0) return;
+    const radius = this.cages.barRadius;
+    const density = this.world.materials.get("steel")?.density ?? STEEL_DENSITY;
+    const material = this.fragments.materialFor("steel", REBAR_COLOR, false);
+    const rnd = createRng(hashString(`${objectId}|${partId}`));
+    bars.forEach((bar, i) => {
+      const fragment = {
+        id: `${partId}#bar${i}`,
+        part: partId,
+        material: "steel",
+        shape: "chunk",
+        center: bar.center,
+        size: [2 * radius, bar.length, 2 * radius],
+        rotation: bar.rotation,
+        velocity: [(rnd() - 0.5) * 0.4, 0, (rnd() - 0.5) * 0.4],
+        angularVelocity: [(rnd() - 0.5) * 1.5, (rnd() - 0.5) * 0.5, (rnd() - 0.5) * 1.5],
+        mass: density * Math.PI * radius * radius * bar.length
+      };
+      this.fragments.spawn(fragment, material, objectId, this.maxFragments, true);
+    });
+  }
   /** Turn every loose group of the object (a detach, a collapse) into a piece of its own. */
   splitLoose(objectId) {
     if (!this.autoSplit) return;
@@ -3623,10 +3952,12 @@ var Renderer = class {
       if (!pv) continue;
       from.parts.delete(p.id);
       nb.parts.set(p.id, pv);
+      this.cages.move(`${from.id}|${p.id}`, `${newId}|${p.id}`, group);
       for (const mv of pv.meshes) {
         if (mv.host && !mv.loose) this.visuals.extract(mv, group);
         else {
           group.attach(mv.mesh);
+          showCollapsedRanges(mv.mesh);
           mv.moved = true;
         }
       }
@@ -3653,6 +3984,45 @@ var Renderer = class {
     if (kitOriginOf(from.root)?.kind === "furniture") this.tipIfTopHeavy(nb);
     this.o.onPiece?.(piece);
   }
+  /**
+   * Furniture that lost what it stood on falls: with every leg of a table broken the top is loose, and with the legs of one side gone what is left topples. Feet are the
+   * meshes at the bottom of the object as it was whole; while the ones left still span the same floor (a cupboard with a broken door, a table missing one leg) it stands.
+   */
+  loosenIfFootless(objectId) {
+    const b = this.bounds.get(objectId);
+    if (!b || !this.autoSplit) return;
+    const left = this.meshesOf(b).filter((mv) => this.visuals.shown(mv));
+    if (left.length === 0) return;
+    const body = b.piece ?? this.pieceSys.get(objectId);
+    if (body) {
+      const { half, center } = this.measure(b.root, left);
+      body.halfExtents = half;
+      this.pieceSys.setCenter(body, center);
+      body.mass = Math.max(0.05, this.massOf(objectId));
+      body.sleeping = false;
+      return;
+    }
+    if (kitOriginOf(b.root)?.kind !== "furniture") return;
+    const boxOf = (mv) => this.visuals.worldBox(mv, new this.THREE.Box3());
+    const whole = [...b.parts.values()].flatMap((pv) => pv.meshes).map(boxOf).filter((one) => !one.isEmpty());
+    const floor = Math.min(...whole.map((one) => one.min.y));
+    const feetOf = (boxes) => boxes.filter((one) => one.min.y < floor + FEET_BAND).reduce((feet, one) => feet.union(one), new this.THREE.Box3());
+    const was = feetOf(whole);
+    const now = feetOf(left.map(boxOf).filter((one) => !one.isEmpty()));
+    const same = !now.isEmpty() && now.min.x <= was.min.x + FEET_BAND && now.max.x >= was.max.x - FEET_BAND && now.min.z <= was.min.z + FEET_BAND && now.max.z >= was.max.z - FEET_BAND;
+    if (same) return;
+    if (!now.isEmpty()) {
+      const box = left.map(boxOf).reduce((all, one) => all.union(one), new this.THREE.Box3());
+      const centreX = (box.min.x + box.max.x) / 2;
+      const centreZ = (box.min.z + box.max.z) / 2;
+      const height = box.max.y - box.min.y;
+      const narrow = height >= TIP_MIN_HEIGHT && Math.min(now.max.x - now.min.x, now.max.z - now.min.z) < TIP_NARROW * height;
+      if (!narrow && centreX > now.min.x && centreX < now.max.x && centreZ > now.min.z && centreZ < now.max.z) return;
+    }
+    const piece = this.makePiece(objectId);
+    this.tipIfTopHeavy(b);
+    this.o.onLoosened?.(objectId, piece, "apart");
+  }
   /**
    * A piece of furniture standing on feet too close for its height (a board on two legs in a line, a lone leg) does not stay up: the box of a piece hides that its weight is up
    * high and its feet are thin, so it gets the start of the fall, across the line of its feet.
@@ -3684,7 +4054,8 @@ var Renderer = class {
     const report = options.report;
     const confinement = report?.find((r) => r.blast !== void 0)?.blast?.confinement ?? 1;
     const energy = ev.energy * confinement;
-    const reachOf = (objectId, at) => report?.find((r) => r.object === objectId)?.blast?.shelter ?? this.world.blastReach?.(p, at, { ignore: ev.object ? [ev.object, objectId] : [objectId] }) ?? 1;
+    const wentOff = this.coverWhenWentOff.get(ev);
+    const reachOf = (objectId, at) => report?.find((r) => r.object === objectId)?.blast?.shelter ?? wentOff?.get(objectId) ?? this.world.blastReach?.(p, at, { ignore: ev.object ? [ev.object, objectId] : [objectId] }) ?? 1;
     const shove = (pc) => {
       this.pieceSys.centerOf(pc, c);
       if (c.distanceTo(this.v2.set(p[0], p[1], p[2])) > ev.radius) return;
@@ -3704,6 +4075,29 @@ var Renderer = class {
       ...report ? { confinement } : {}
     });
   }
+  /** The cover between a part of the world that goes off and the centre of each piece and each shoveable body within its radius, as the world stands at that moment. */
+  coverAround(ev) {
+    const cover = /* @__PURE__ */ new Map();
+    const reach = this.world.blastReach;
+    if (!reach) return cover;
+    const point = new this.THREE.Vector3(ev.point[0], ev.point[1], ev.point[2]);
+    const centre = new this.THREE.Vector3();
+    const read = (objectId) => {
+      if (centre.distanceTo(point) <= ev.radius) cover.set(objectId, reach.call(this.world, ev.point, [centre.x, centre.y, centre.z], { ignore: [ev.object, objectId] }));
+    };
+    for (const pc of this.pieceSys.list) {
+      this.pieceSys.centerOf(pc, centre);
+      read(pc.objectId);
+    }
+    const shoveable = this.o.shoveable;
+    if (!shoveable) return cover;
+    for (const b of this.bounds.values()) {
+      if (b.piece || cover.has(b.id) || !shoveable(b.id) || !this.world.has(b.id)) continue;
+      centre.copy(this.measure(b.root, this.meshesOf(b)).center).applyQuaternion(b.root.quaternion).add(b.root.position);
+      read(b.id);
+    }
+    return cover;
+  }
   /** The bound objects without a piece that the host lets a blast move (`shoveable`): the ones it reaches with enough speed become pieces and get the shove. */
   loosen(point, radius, energy, reachOf) {
     const shoveable = this.o.shoveable;