@adatechnology/game-test-room 0.1.2 → 0.1.3

package/dist/index.global.js

@@ -1646,6 +1646,7 @@ var GameTestRoom = (() => {
   var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
   var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
   var clone = (v) => structuredClone(v);
+  var overloadRate = (stress) => Math.min(0.6, 0.12 + 0.8 * (stress - 1));
   var updateBound = (o) => {
     if (!o.parts.length) return;
     const c = [0, 0, 0];
@@ -1956,7 +1957,10 @@ var GameTestRoom = (() => {
         for (const g of o.st.groups) {
           const ps = g.map((id) => o.byId.get(id)).filter((p) => !isLost(p) && !o.collapsed.has(p.spec.id));
           if (ps.length === 0 || g.some((id) => o.byId.get(id).anchored) || !ps.some((p) => p.structural)) continue;
-          for (const p of ps) o.collapsed.add(p.spec.id);
+          for (const p of ps) {
+            o.collapsed.add(p.spec.id);
+            p.st.status = "collapsed";
+          }
           emit({ ...base(o, src), type: "collapse", parts: ps.map((p) => p.spec.id), mass: ps.reduce((sum, p) => sum + p.st.mass, 0) });
         }
       }
@@ -2256,7 +2260,7 @@ var GameTestRoom = (() => {
       const effM = p.thickness / Math.max(sin, 0.3);
       const thr = mat.penetration * effM * 1e3;
       const penetrated = E > thr;
-      const scale2 = mat.damageScale?.ballistic ?? 1;
+      const scale2 = (mat.damageScale?.ballistic ?? 1) * (mat.fracture === "shatter" ? fragility(mat.ductility, p.thickness) : 1);
       const id = p.spec.id;
       if (!penetrated && mat.ricochetDeg && angle < mat.ricochetDeg) {
         const r = vec.sub(d, vec.scale(n, 2 * vec.dot(d, n)));
@@ -2606,7 +2610,7 @@ var GameTestRoom = (() => {
               p.rt.stressT = 0.5;
               emit({ ...base(o), type: "stress", part: p.spec.id, stress, load: p.st.load ?? 0 });
             }
-            applyDamage(o, p, (stress - 1) * p.st.maxHp * 0.5 * dt, "blunt", null, null, 5, 3);
+            applyDamage(o, p, overloadRate(stress) * p.st.maxHp * dt, "blunt", null, null, 5, 3);
           } else if (stress > 0.8 && p.mat.ductility < 0.3 && p.rt.stressT <= 0 && p.st.cracks.length < 6) {
             p.rt.stressT = 0.5;
             const { c, q } = partXf(o, p);
@@ -3096,7 +3100,7 @@ var GameTestRoom = (() => {
         wax: "wax",
         soil: "soil"
       },
-      partStatus: { intact: "intact", damaged: "damaged", broken: "broken", melted: "melted", ashes: "ashes" },
+      partStatus: { intact: "intact", damaged: "damaged", collapsed: "collapsed", broken: "broken", melted: "melted", ashes: "ashes" },
       jointKinds: {
         screw: "screw",
         bolt: "nut and bolt",
@@ -3177,7 +3181,7 @@ var GameTestRoom = (() => {
         wax: "cera",
         soil: "terra"
       },
-      partStatus: { intact: "intacto", damaged: "danificado", broken: "quebrado", melted: "derretido", ashes: "cinzas" },
+      partStatus: { intact: "intacto", damaged: "danificado", collapsed: "desabado", broken: "quebrado", melted: "derretido", ashes: "cinzas" },
       jointKinds: {
         screw: "parafuso",
         bolt: "porca e parafuso",
@@ -4472,6 +4476,8 @@ void main() {
       __publicField(this, "b");
       __publicField(this, "m4");
       __publicField(this, "box");
+      __publicField(this, "t");
+      __publicField(this, "lbox");
       __publicField(this, "decalCount", 0);
       __publicField(this, "tints", /* @__PURE__ */ new WeakMap());
       this.kit = new DecalKit(THREE);
@@ -4479,9 +4485,22 @@ void main() {
       this.b = tmpV(THREE);
       this.m4 = new THREE.Matrix4();
       this.box = new THREE.Box3();
+      this.t = tmpV(THREE);
+      this.lbox = new THREE.Box3();
     }
-    makeMeshVis(mesh, home) {
-      return {
+    /**
+     * @param range vertex range `[v0, v1)` of a merged mesh this part is drawn by (see `MeshRange`); `hosts` caches the shared state per mesh for one `bind`.
+     */
+    makeMeshVis(mesh, home, range, hosts) {
+      let host = null;
+      if (range) {
+        host = hosts?.get(mesh) ?? null;
+        if (!host) {
+          host = { mesh, origGeometry: mesh.geometry, origMaterial: mesh.material, ownGeo: false, work: null, ownMat: false, sharers: [] };
+          hosts?.set(mesh, host);
+        }
+      }
+      const mv = {
         mesh,
         home,
         origGeometry: mesh.geometry,
@@ -4498,31 +4517,72 @@ void main() {
         decals: [],
         meltApplied: 0,
         bottomY: 0,
-        moved: false
+        moved: false,
+        host,
+        range: range ? [range[0], range[1]] : null,
+        merged: host && range ? { host, range: [range[0], range[1]] } : null,
+        loose: false,
+        collapsed: false,
+        hidden: false,
+        touched: false,
+        charK: 0,
+        charHex: 0,
+        glowHex: 0,
+        glowK: 0
       };
+      host?.sharers.push(mv);
+      return mv;
     }
     vertexCount(mv) {
+      if (mv.range) return mv.range[1] - mv.range[0];
       return mv.mesh.geometry.getAttribute(POS_ATTR)?.count ?? 0;
     }
+    /** Is the part drawn? (A ranged part shares its mesh, so `mesh.visible` says nothing about it.) */
+    shown(mv) {
+      return mv.host ? !mv.hidden : mv.mesh.visible;
+    }
+    /** Box of the part's vertices in the space of its mesh (the whole geometry for a plain mesh). */
+    localBox(mv, out) {
+      out.makeEmpty();
+      if (!mv.host || !mv.range) {
+        const geo = mv.mesh.geometry;
+        if (!geo.boundingBox) geo.computeBoundingBox();
+        return geo.boundingBox ? out.copy(geo.boundingBox) : out;
+      }
+      const arr = mv.host.work ?? positionAttr(mv.mesh.geometry)?.array;
+      if (!arr) return out;
+      for (let i = mv.range[0] * 3; i < mv.range[1] * 3; i += 3) out.expandByPoint(this.t.set(arr[i], arr[i + 1], arr[i + 2]));
+      return out;
+    }
+    /** Box of the part in world space. */
+    worldBox(mv, out) {
+      if (!mv.host) return out.setFromObject(mv.mesh);
+      this.localBox(mv, out);
+      mv.mesh.updateWorldMatrix(true, false);
+      return out.isEmpty() ? out : out.applyMatrix4(mv.mesh.matrixWorld);
+    }
     /**
      * Average vertex colour of a mesh whose material uses `vertexColors` (computed once per mesh, from its original geometry), else null. Fragments
      * and debris of such a mesh multiply it by `material.color`; without it they come out white.
      */
     vertexTint(mv) {
-      if (this.tints.has(mv.mesh)) return this.tints.get(mv.mesh) ?? null;
+      if (this.tints.has(mv)) return this.tints.get(mv) ?? null;
       let tint = null;
       const used = materialsOf(mv.origMaterial).some((m) => m.vertexColors === true);
       const attr = used ? mv.origGeometry.getAttribute("color") : void 0;
       if (attr && attr.count > 0 && attr.itemSize >= 3) {
+        const from = mv.merged ? mv.merged.range[0] : 0;
+        const to = mv.merged ? Math.min(attr.count, mv.merged.range[1]) : attr.count;
         let r = 0, g = 0, b = 0;
-        for (let i = 0; i < attr.count; i++) {
+        for (let i = from; i < to; i++) {
           r += attr.getX(i);
           g += attr.getY(i);
           b += attr.getZ(i);
         }
-        tint = new this.THREE.Color(r / attr.count, g / attr.count, b / attr.count);
+        const n = Math.max(1, to - from);
+        tint = new this.THREE.Color(r / n, g / n, b / n);
       }
-      this.tints.set(mv.mesh, tint);
+      this.tints.set(mv, tint);
       return tint;
     }
     /** Colour of the original material (before any char) times the vertex tint, `0xRRGGBB`, or -1. */
@@ -4546,6 +4606,7 @@ void main() {
     }
     /** Clone the geometry (vertex edits); false when its positions cannot be edited. */
     ownGeometry(mv) {
+      if (mv.host) return this.ownHostGeometry(mv.host);
       if (mv.ownGeo) return true;
       const pos = positionAttr(mv.mesh.geometry);
       if (!pos) return false;
@@ -4555,6 +4616,16 @@ void main() {
       mv.work = new Float32Array(positionAttr(g).array);
       return true;
     }
+    ownHostGeometry(host) {
+      if (host.ownGeo) return true;
+      const pos = positionAttr(host.mesh.geometry);
+      if (!pos) return false;
+      host.ownGeo = true;
+      const g = host.mesh.geometry.clone();
+      host.mesh.geometry = g;
+      host.work = new Float32Array(positionAttr(g).array);
+      return true;
+    }
     // ------------------------------------------------------------------------------------------------------------------------------------
     // Dents
     // ------------------------------------------------------------------------------------------------------------------------------------
@@ -4572,10 +4643,15 @@ void main() {
       const r = dent.radius / s;
       const depth = dent.depth / s;
       const geo = mesh.geometry;
-      if (!geo.boundingBox) geo.computeBoundingBox();
-      if (geo.boundingBox && geo.boundingBox.distanceToPoint(lp) > r) return false;
+      let bb;
+      if (mv.host) bb = this.localBox(mv, this.lbox);
+      else {
+        if (!geo.boundingBox) geo.computeBoundingBox();
+        bb = geo.boundingBox;
+      }
+      if (bb && !bb.isEmpty() && bb.distanceToPoint(lp) > r) return false;
       if (!this.ownGeometry(mv)) return false;
-      const work = mv.work;
+      const work = mv.host ? mv.host.work : mv.work;
       const pos = positionAttr(mesh.geometry);
       const r2 = r * r;
       let touched = false;
@@ -4585,7 +4661,9 @@ void main() {
       const nx = ln.x;
       const ny = ln.y;
       const nz = ln.z;
-      for (let i = 0; i < work.length; i += 3) {
+      const from = mv.range ? mv.range[0] * 3 : 0;
+      const to = mv.range ? mv.range[1] * 3 : work.length;
+      for (let i = from; i < to; i += 3) {
         const dx = work[i] - px;
         const dy = work[i + 1] - py;
         const dz = work[i + 2] - pz;
@@ -4599,11 +4677,16 @@ void main() {
         touched = true;
       }
       if (!touched) return false;
+      mv.touched = true;
       this.writePositions(mv, pos);
       return true;
     }
     /** Copy `work` (dents) into the geometry, adding the melt sag when the mesh is melting. */
     writePositions(mv, pos) {
+      if (mv.host) {
+        this.rebuildHost(mv.host);
+        return;
+      }
       const work = mv.work;
       const arr = pos.array;
       const melt = mv.meltApplied;
@@ -4717,6 +4800,12 @@ void main() {
       pv.charApplied = char;
       const target = new this.THREE.Color(charColor);
       for (const mv of pv.meshes) {
+        if (mv.host) {
+          mv.charK = clamp3(char, 0, 1);
+          mv.charHex = charColor;
+          this.paint(mv);
+          continue;
+        }
         this.ownMaterial(mv);
         const mats = materialsOf(mv.mesh.material);
         mats.forEach((m, i) => {
@@ -4734,6 +4823,12 @@ void main() {
       pv.glowApplied = key;
       const intensity = hex === 0 ? 0 : clamp3(0.35 + (temperatureC - 450) / 900, 0, 1.4);
       for (const mv of pv.meshes) {
+        if (mv.host) {
+          mv.glowHex = hex;
+          mv.glowK = intensity;
+          this.paint(mv);
+          continue;
+        }
         this.ownMaterial(mv);
         for (const m of materialsOf(mv.mesh.material)) {
           const e = m.emissive;
@@ -4754,6 +4849,12 @@ void main() {
       pv.meltApplied = m;
       for (const mv of pv.meshes) {
         const mesh = mv.mesh;
+        if (mv.host) {
+          mv.meltApplied = m;
+          mv.touched = true;
+          if (!(this.lowQuality && this.vertexCount(mv) > 2e4) && this.ownGeometry(mv)) this.rebuildHost(mv.host);
+          continue;
+        }
         if (mv.meltApplied === 0 && m > 0) {
           mesh.updateWorldMatrix(true, false);
           mv.bottomY = this.box.setFromObject(mesh).min.y;
@@ -4784,10 +4885,270 @@ void main() {
     // ------------------------------------------------------------------------------------------------------------------------------------
     hide(pv, reason) {
       pv.gone = reason;
-      for (const mv of pv.meshes) mv.mesh.visible = false;
+      for (const mv of pv.meshes) {
+        if (!mv.host || mv.loose) {
+          mv.mesh.visible = false;
+          mv.hidden = true;
+          continue;
+        }
+        mv.hidden = true;
+        for (const d of mv.decals) d.obj.visible = false;
+        this.collapse(mv);
+      }
+    }
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    // Parts drawn by a vertex range of a merged mesh
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    /** Collapse the part's vertices in the merged mesh to one point (its triangles become degenerate and vanish). */
+    collapse(mv) {
+      if (!mv.merged || !this.ownHostGeometry(mv.merged.host)) return;
+      mv.collapsed = true;
+      mv.touched = true;
+      this.rebuildHost(mv.merged.host);
+    }
+    /** Write `work` into the geometry again with the melt of ranged parts and the collapsed ranges applied. */
+    rebuildHost(host) {
+      const geo = host.mesh.geometry;
+      const pos = positionAttr(geo);
+      const work = host.work;
+      if (!pos || !work) return;
+      const arr = pos.array;
+      arr.set(work);
+      for (const s of host.sharers) {
+        if (s.merged && s.merged.host === host) {
+          if (s.collapsed) this.collapseRange(arr, s.merged.range);
+          else if (s.meltApplied > 0 && !s.loose) this.meltRange(arr, work, s.merged.range, s.meltApplied);
+        } else if (s.host === host && s.range && s.meltApplied > 0) this.meltRange(arr, work, s.range, s.meltApplied);
+      }
+      pos.needsUpdate = true;
+      geo.computeVertexNormals();
+      geo.boundingBox = null;
+      geo.boundingSphere = null;
+    }
+    collapseRange(arr, range) {
+      const x = arr[range[0] * 3];
+      const y = arr[range[0] * 3 + 1];
+      const z = arr[range[0] * 3 + 2];
+      for (let i = range[0] * 3; i < range[1] * 3; i += 3) {
+        arr[i] = x;
+        arr[i + 1] = y;
+        arr[i + 2] = z;
+      }
+    }
+    /** Melt of one range: shorter in Y (down to 25 %) with the bottom fixed, a bit wider around its centre, with the same noise as a whole mesh. */
+    meltRange(arr, work, range, melt) {
+      let minY = Infinity;
+      let maxY = -Infinity;
+      let cx = 0;
+      let cz = 0;
+      const n = Math.max(1, range[1] - range[0]);
+      for (let i = range[0] * 3; i < range[1] * 3; i += 3) {
+        minY = Math.min(minY, work[i + 1]);
+        maxY = Math.max(maxY, work[i + 1]);
+        cx += work[i];
+        cz += work[i + 2];
+      }
+      cx /= n;
+      cz /= n;
+      const h = Math.max(1e-4, maxY - minY);
+      const sy = lerp(1, 0.25, melt);
+      const sxz = 1 + 0.18 * melt;
+      for (let i = range[0] * 3, v = 0; i < range[1] * 3; i += 3, v++) {
+        const noise = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
+        arr[i] = cx + (work[i] - cx) * sxz;
+        arr[i + 2] = cz + (work[i + 2] - cz) * sxz;
+        arr[i + 1] = Math.max(minY, minY + (work[i + 1] - minY) * sy - noise * melt * h * 0.04);
+      }
+    }
+    /** The colour attribute of the host's current geometry (created white when there is none) with vertex colours switched on in its material. */
+    ensureColors(host) {
+      if (!this.ownHostGeometry(host)) return null;
+      const geo = host.mesh.geometry;
+      let attr = geo.getAttribute("color");
+      if (!attr) {
+        const n = geo.getAttribute(POS_ATTR).count;
+        attr = new this.THREE.BufferAttribute(new Float32Array(n * 3).fill(1), 3);
+        geo.setAttribute("color", attr);
+      }
+      if (!host.ownMat) {
+        host.ownMat = true;
+        const src = materialsOf(host.mesh.material);
+        const cloned = src.map((m) => m.clone());
+        host.mesh.material = Array.isArray(host.mesh.material) ? cloned : cloned[0];
+      }
+      for (const m of materialsOf(host.mesh.material)) {
+        if (m.vertexColors !== true) {
+          ;
+          m.vertexColors = true;
+          m.needsUpdate = true;
+        }
+      }
+      return attr;
+    }
+    /** Colour of the part's vertices from the original colours, its char and its heat. Only the part's range is written. */
+    paint(mv) {
+      if (!mv.host || !mv.range || !mv.merged) return;
+      const idle = mv.charK <= 0 && mv.glowK <= 0;
+      if (idle && !mv.touched) return;
+      const attr = this.ensureColors(mv.host);
+      if (!attr) return;
+      const size = attr.itemSize;
+      const arr = attr.array;
+      const orig = mv.merged.host.origGeometry.getAttribute("color");
+      const oSize = orig?.itemSize ?? 3;
+      const oArr = orig?.array;
+      const shift = mv.merged.range[0] - mv.range[0];
+      const ch = new this.THREE.Color(mv.charHex);
+      const heat = new this.THREE.Color(mv.glowHex);
+      const k = clamp3(mv.charK, 0, 1);
+      const gk = clamp3(mv.glowK, 0, 1);
+      const boost = 1 + Math.max(0, mv.glowK - 1);
+      for (let i = mv.range[0]; i < mv.range[1]; i++) {
+        const o = (i + shift) * oSize;
+        let r = oArr ? oArr[o] : 1;
+        let g = oArr ? oArr[o + 1] : 1;
+        let b = oArr ? oArr[o + 2] : 1;
+        if (k > 0) {
+          r = lerp(r, ch.r, k);
+          g = lerp(g, ch.g, k);
+          b = lerp(b, ch.b, k);
+        }
+        if (gk > 0) {
+          r = lerp(r, heat.r * boost, gk);
+          g = lerp(g, heat.g * boost, gk);
+          b = lerp(b, heat.b * boost, gk);
+        }
+        arr[i * size] = r;
+        arr[i * size + 1] = g;
+        arr[i * size + 2] = b;
+      }
+      mv.touched = true;
+      attr.needsUpdate = true;
+    }
+    /**
+     * Move a ranged part to a mesh of its own: the faces whose vertices all lie in its range are copied (with the current dents and colours) into a
+     * new mesh that takes the merged mesh's transform and material, then attached to `group`; the range is collapsed in the merged mesh. Decals
+     * go with it.
+     */
+    extract(mv, group) {
+      if (!mv.host || !mv.range || !mv.merged || mv.loose) return;
+      const host = mv.host;
+      const [v0, v1] = mv.range;
+      const src = host.mesh.geometry;
+      const geo = new this.THREE.BufferGeometry();
+      const count = v1 - v0;
+      for (const name of Object.keys(src.attributes)) {
+        const a = src.getAttribute(name);
+        if (a.isInterleavedBufferAttribute) continue;
+        const size = a.itemSize;
+        const from = (name === POS_ATTR ? 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));
+      }
+      const index = src.getIndex();
+      if (index) {
+        const out = [];
+        for (let i = 0; i + 2 < index.count; i += 3) {
+          const a = index.getX(i);
+          const b = index.getX(i + 1);
+          const c = index.getX(i + 2);
+          if (a >= v0 && a < v1 && b >= v0 && b < v1 && c >= v0 && c < v1) out.push(a - v0, b - v0, c - v0);
+        }
+        geo.setIndex(count > 65535 ? new this.THREE.Uint32BufferAttribute(out, 1) : new this.THREE.Uint16BufferAttribute(out, 1));
+      }
+      const mats = materialsOf(host.mesh.material).map((m) => m.clone());
+      const loose = new this.THREE.Mesh(geo, mats[0]);
+      loose.name = `${host.mesh.name || "mesh"}:${v0}-${v1}`;
+      loose.castShadow = host.mesh.castShadow;
+      loose.receiveShadow = host.mesh.receiveShadow;
+      loose.renderOrder = host.mesh.renderOrder;
+      loose.frustumCulled = host.mesh.frustumCulled;
+      loose.layers.mask = host.mesh.layers.mask;
+      loose.position.copy(host.mesh.position);
+      loose.quaternion.copy(host.mesh.quaternion);
+      loose.scale.copy(host.mesh.scale);
+      const parent = host.mesh.parent;
+      if (parent) parent.add(loose);
+      loose.updateMatrixWorld(true);
+      this.collapse(mv);
+      for (const d of mv.decals) {
+        d.obj.visible = true;
+        loose.add(d.obj);
+      }
+      const lp = positionAttr(geo);
+      const lh = {
+        mesh: loose,
+        origGeometry: geo,
+        origMaterial: loose.material,
+        ownGeo: true,
+        work: new Float32Array(lp.array),
+        ownMat: true,
+        sharers: [mv]
+      };
+      mv.host = lh;
+      mv.range = [0, count];
+      mv.mesh = loose;
+      mv.loose = true;
+      mv.moved = true;
+      group.attach(loose);
+      for (const m of materialsOf(loose.material)) m.needsUpdate = true;
+    }
+    restoreRanged(mv) {
+      const merged = mv.merged;
+      const host = merged.host;
+      for (const d of mv.decals) this.disposeDecal(d);
+      mv.decals.length = 0;
+      if (mv.loose) {
+        const loose = mv.mesh;
+        loose.parent?.remove(loose);
+        loose.geometry.dispose();
+        for (const m of materialsOf(loose.material)) m.dispose();
+        mv.host = host;
+        mv.range = [merged.range[0], merged.range[1]];
+        mv.mesh = host.mesh;
+        mv.loose = false;
+        mv.moved = false;
+      }
+      mv.collapsed = false;
+      mv.hidden = false;
+      mv.meltApplied = 0;
+      mv.charK = 0;
+      mv.glowK = 0;
+      mv.touched = false;
+      if (!host.ownGeo) return;
+      const work = host.work;
+      const op = positionAttr(host.origGeometry);
+      const [v0, v1] = merged.range;
+      if (op) work.set(op.array.subarray(v0 * 3, v1 * 3), v0 * 3);
+      const attr = host.mesh.geometry.getAttribute("color");
+      if (attr) {
+        const orig = host.origGeometry.getAttribute("color");
+        const size = attr.itemSize;
+        const a = attr.array;
+        for (let i = v0; i < v1; i++) {
+          for (let c = 0; c < 3; c++) a[i * size + c] = orig ? orig.array[i * orig.itemSize + c] : 1;
+        }
+        attr.needsUpdate = true;
+      }
+      if (host.sharers.every((s) => !s.touched)) {
+        host.mesh.geometry.dispose();
+        host.mesh.geometry = host.origGeometry;
+        host.work = null;
+        host.ownGeo = false;
+        if (host.ownMat) {
+          for (const m of materialsOf(host.mesh.material)) m.dispose();
+          host.mesh.material = host.origMaterial;
+          host.ownMat = false;
+        }
+      } else this.rebuildHost(host);
     }
     /** Bring one mesh back to how it was when it was bound. */
     restoreMesh(mv) {
+      if (mv.merged) {
+        this.restoreRanged(mv);
+        return;
+      }
       const mesh = mv.mesh;
       for (const d of mv.decals) this.disposeDecal(d);
       mv.decals.length = 0;
@@ -4885,6 +5246,10 @@ void main() {
   function materialsOf2(m) {
     return Array.isArray(m) ? m : [m];
   }
+  function isMeshRange(v) {
+    const r = v;
+    return !!r.mesh && Array.isArray(r.range);
+  }
   function createDestructionRenderer(THREE, options) {
     return new Renderer(THREE, options);
   }
@@ -4978,12 +5343,23 @@ void main() {
       const partIds = new Set((state?.parts ?? []).map((p) => p.id));
       const byPart = /* @__PURE__ */ new Map();
       const taken = /* @__PURE__ */ new Set();
+      const put = (pid, e) => {
+        const l = byPart.get(pid);
+        if (l) l.push(e);
+        else byPart.set(pid, [e]);
+      };
       const add2 = (pid, m) => {
         if (taken.has(m)) return;
         taken.add(m);
-        const l = byPart.get(pid);
-        if (l) l.push(m);
-        else byPart.set(pid, [m]);
+        put(pid, { mesh: m });
+      };
+      const addRange = (pid, r) => {
+        const n = r.mesh.geometry.getAttribute("position")?.count ?? 0;
+        const [v0, v1] = r.range;
+        if (!Number.isInteger(v0) || !Number.isInteger(v1) || v0 < 0 || v1 <= v0 || v1 > n) {
+          throw new Error(`game-destruction-three: invalid vertex range [${v0}, ${v1}) for part "${pid}" (the mesh has ${n} vertices)`);
+        }
+        put(pid, { mesh: r.mesh, range: [v0, v1] });
       };
       const meshesIn = (o) => {
         const out = [];
@@ -4994,7 +5370,10 @@ void main() {
       };
       if (options.parts) {
         for (const [pid, v] of Object.entries(options.parts)) {
-          for (const o of Array.isArray(v) ? v : [v]) for (const m of meshesIn(o)) add2(pid, m);
+          for (const o of Array.isArray(v) ? v : [v]) {
+            if (isMeshRange(o)) addRange(pid, o);
+            else for (const m of meshesIn(o)) add2(pid, m);
+          }
         }
       } else {
         const leftovers = [];
@@ -5007,14 +5386,15 @@ void main() {
         if (leftovers.length) this.matchByBox(objectId, root, leftovers, add2);
       }
       const bound = { id: objectId, root, sync: options.syncTransform !== false, parts: /* @__PURE__ */ new Map(), lastPos: null, lastQuat: null, piece: null, isSplit: false };
-      for (const pid of partIds) bound.parts.set(pid, this.makePartVis(objectId, pid, state?.parts.find((p) => p.id === pid)?.material ?? "", byPart.get(pid) ?? []));
+      const hosts = /* @__PURE__ */ new Map();
+      for (const pid of partIds) bound.parts.set(pid, this.makePartVis(objectId, pid, state?.parts.find((p) => p.id === pid)?.material ?? "", byPart.get(pid) ?? [], hosts));
       for (const [pid, meshes] of byPart) {
-        if (!bound.parts.has(pid)) bound.parts.set(pid, this.makePartVis(objectId, pid, this.world.part(objectId, pid)?.material ?? "", meshes));
+        if (!bound.parts.has(pid)) bound.parts.set(pid, this.makePartVis(objectId, pid, this.world.part(objectId, pid)?.material ?? "", meshes, hosts));
       }
       this.bounds.set(objectId, bound);
     }
-    makePartVis(home, id, material, meshes) {
-      return { id, home, material, meshes: meshes.map((m) => this.visuals.makeMeshVis(m, home)), charApplied: 0, glowApplied: 0, meltApplied: 0, gone: "none" };
+    makePartVis(home, id, material, meshes, hosts) {
+      return { id, home, material, meshes: meshes.map((m) => this.visuals.makeMeshVis(m.mesh, home, m.range, hosts)), charApplied: 0, glowApplied: 0, meltApplied: 0, gone: "none" };
     }
     /** Match unlabelled meshes to the part whose shape contains the centre of the mesh's bounding box. */
     matchByBox(objectId, root, meshes, add2) {
@@ -5074,11 +5454,13 @@ void main() {
       const inv = root.matrixWorld.clone().invert();
       const total = new this.THREE.Box3();
       const m4 = new this.THREE.Matrix4();
-      for (const m of meshes) {
-        const g = m.geometry;
-        if (!g.boundingBox) g.computeBoundingBox();
-        if (!g.boundingBox || g.boundingBox.isEmpty()) continue;
-        total.union(g.boundingBox.clone().applyMatrix4(m4.multiplyMatrices(inv, m.matrixWorld)));
+      const lb = new this.THREE.Box3();
+      for (const mv of meshes) {
+        const m = mv.mesh;
+        m.updateWorldMatrix(true, false);
+        this.visuals.localBox(mv, lb);
+        if (lb.isEmpty()) continue;
+        total.union(lb.clone().applyMatrix4(m4.multiplyMatrices(inv, m.matrixWorld)));
       }
       if (total.isEmpty()) return { half: [0.25, 0.25, 0.25], center: new this.THREE.Vector3() };
       const size = total.getSize(new this.THREE.Vector3());
@@ -5086,7 +5468,7 @@ void main() {
     }
     meshesOf(b) {
       const out = [];
-      for (const pv of b.parts.values()) if (pv.gone === "none") for (const mv of pv.meshes) out.push(mv.mesh);
+      for (const pv of b.parts.values()) if (pv.gone === "none") for (const mv of pv.meshes) out.push(mv);
       return out;
     }
     massOf(objectId) {
@@ -5217,6 +5599,9 @@ void main() {
         case "detach":
           this.onDetach(ev);
           break;
+        case "collapse":
+          this.splitLoose(ev.object);
+          break;
         case "disassemble_progress": {
           const k = `unscrew:${ev.joint}`;
           if (this.time - (this.throttles.get(k) ?? -1) > 0.25) {
@@ -5335,8 +5720,8 @@ void main() {
       let best = null;
       let bd = Infinity;
       for (const mv of pv.meshes) {
-        if (!mv.mesh.visible) continue;
-        const d = this.box.setFromObject(mv.mesh).distanceToPoint(p);
+        if (!this.visuals.shown(mv)) continue;
+        const d = this.visuals.worldBox(mv, this.box).distanceToPoint(p);
         if (d < bd) {
           bd = d;
           best = mv;
@@ -5356,7 +5741,7 @@ void main() {
       const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
       const wn = this.worldDir(b, ev.dent.normal);
       for (const mv of pv.meshes) {
-        if (!mv.mesh.visible) continue;
+        if (!this.visuals.shown(mv)) continue;
         this.visuals.applyDent(mv, wp, wn, ev.dent);
       }
       if (def?.tags?.includes("metal")) this.particles.burst("sparks", ev.worldPoint, [wn.x, wn.y, wn.z], 4 + Math.min(8, ev.dent.depth * 150), 3.2);
@@ -5447,16 +5832,20 @@ void main() {
     }
     onDetach(ev) {
       this.sound("detach", this.rootPoint(ev.object), 0.5);
+      this.splitLoose(ev.object);
+    }
+    /** Turn every loose group of the object (a detach, a collapse) into a piece of its own. */
+    splitLoose(objectId) {
       if (!this.autoSplit) return;
-      const b = this.bounds.get(ev.object);
+      const b = this.bounds.get(objectId);
       if (!b) return;
-      const st = this.world.state(ev.object);
+      const st = this.world.state(objectId);
       if (!st || st.groups.length < 2) return;
       const loose = st.groups.length - 1;
       for (let i = 0; i < loose; i++) {
         let newId;
         try {
-          newId = this.world.splitGroup(ev.object, 1);
+          newId = this.world.splitGroup(objectId, 1);
         } catch {
           break;
         }
@@ -5467,7 +5856,7 @@ void main() {
         const { half, center } = this.measure(b.root, this.meshesOf(b));
         old.halfExtents = half;
         this.pieceSys.setCenter(old, center);
-        old.mass = Math.max(0.05, this.massOf(ev.object));
+        old.mass = Math.max(0.05, this.massOf(objectId));
         old.sleeping = false;
       }
     }
@@ -5489,8 +5878,11 @@ void main() {
         from.parts.delete(p.id);
         nb.parts.set(p.id, pv);
         for (const mv of pv.meshes) {
-          group.attach(mv.mesh);
-          mv.moved = true;
+          if (mv.host && !mv.loose) this.visuals.extract(mv, group);
+          else {
+            group.attach(mv.mesh);
+            mv.moved = true;
+          }
         }
       }
       this.bounds.set(newId, nb);
@@ -5606,7 +5998,7 @@ void main() {
     }
     onGone(objectId, pv, reason, def) {
       const bb = new this.THREE.Box3();
-      for (const mv of pv.meshes) bb.union(this.box.setFromObject(mv.mesh));
+      for (const mv of pv.meshes) bb.union(this.visuals.worldBox(mv, this.box));
       this.visuals.hide(pv, reason);
       if (bb.isEmpty()) return;
       const c = bb.getCenter(new this.THREE.Vector3());
@@ -5623,7 +6015,7 @@ void main() {
       const bb = this.box;
       bb.makeEmpty();
       const tmp = new this.THREE.Box3();
-      for (const mv of pv.meshes) if (mv.mesh.visible) bb.union(tmp.setFromObject(mv.mesh));
+      for (const mv of pv.meshes) if (this.visuals.shown(mv)) bb.union(this.visuals.worldBox(mv, tmp));
       let cx = f.point[0];
       let cy = f.point[1];
       let cz = f.point[2];
@@ -10885,8 +11277,8 @@ void main() {
       "sc.concrete_stops_bullet.check": "9 mm into 40 cm of concrete: went through: {through}, {dents}, {holes}, {cracks}, block {hp} hp (expected: stopped, wall behind untouched)",
       "sc.hammer_dents_drum": "Hammer dents a steel drum",
       "sc.hammer_dents_drum.check": "Hammer on the drum: {swings} swing(s), {dents} dent(s), first {depth} mm deep, body {hp} hp (expected: dented, not broken)",
-      "sc.glass_shatters": "Glass pane shatters after a few 9 mm shots",
-      "sc.glass_shatters.check": "Glass pane: broken after {shots} shot(s) into {n} shards (expected: broken, at least 4 shards)",
+      "sc.glass_shatters": "Glass pane shatters on the first 9 mm shot",
+      "sc.glass_shatters.check": "Glass pane: broken after {shots} shot(s) into {n} shards (expected: broken on the first shot, at least 4 shards)",
       "sc.shotgun_splinters_crate": "Shotgun splinters a wooden crate",
       "sc.shotgun_splinters_crate.check": "12 ga on the crate: {shots} shot(s), {splinters} board(s) splintered, {holes} holes (expected: at least one splintered)",
       "sc.kick_chair_leg": "A kick takes a chair leg off",
@@ -11174,8 +11566,8 @@ void main() {
       "sc.concrete_stops_bullet.check": "9 mm em 40 cm de concreto: atravessou: {through}, {dents}, {holes}, {cracks}, bloco com {hp} hp (esperado: parou, parede atr\xE1s intacta)",
       "sc.hammer_dents_drum": "Martelo amassa um tambor de a\xE7o",
       "sc.hammer_dents_drum.check": "Martelo no tambor: {swings} golpe(s), {dents} amassado(s), o primeiro com {depth} mm, corpo com {hp} hp (esperado: amassado, sem quebrar)",
-      "sc.glass_shatters": "Vidro estilha\xE7a depois de alguns tiros de 9 mm",
-      "sc.glass_shatters.check": "Vidro: quebrou depois de {shots} tiro(s) em {n} cacos (esperado: quebrado, pelo menos 4 cacos)",
+      "sc.glass_shatters": "Vidro estilha\xE7a no primeiro tiro de 9 mm",
+      "sc.glass_shatters.check": "Vidro: quebrou depois de {shots} tiro(s) em {n} cacos (esperado: quebrado no primeiro tiro, pelo menos 4 cacos)",
       "sc.shotgun_splinters_crate": "Escopeta lasca um caixote de madeira",
       "sc.shotgun_splinters_crate.check": "Calibre 12 no caixote: {shots} tiro(s), {splinters} t\xE1bua(s) lascada(s), {holes} furos (esperado: pelo menos uma lascada)",
       "sc.kick_chair_leg": "Um chute solta a perna da cadeira",
@@ -12617,7 +13009,7 @@ void main() {
         step(0.5);
         const fr = room.log.entries({ type: "fracture", objectId: id }).find((e) => e.part === "pane");
         const n = Number(fr?.data?.fragments ?? 0);
-        expect(part(room, id, "pane")?.status === "broken" && n >= 4, t("sc.glass_shatters.check", { shots, n }), { shots, fragments: n });
+        expect(part(room, id, "pane")?.status === "broken" && shots === 1 && n >= 4, t("sc.glass_shatters.check", { shots, n }), { shots, fragments: n });
       }),
       sc("shotgun_splinters_crate", ({ room, step, expect }) => {
         const id = at(room, "wooden_crate", 0, -4);