Destroy debris: landed shards and dust fade out soon after landing instead of resting 25 to 30 s on the undrawn floor, where they read as hanging in mid-air; reset clears every instanced slot; watchdog retires anything drawn and unmoving for 2.5 s; damageStats reports stillMax, stillAirMax, retired

app.js

@@ -1276,6 +1276,7 @@ requestAnimationFrame(() => loadOverlay());
 // camera hooks for the keyboard shortcuts in polish.js
 window.unrollView = {
   damageStats: () => damage.stats(),
+  damageSim: (n, dt) => damage.simulate(n, dt),   // test hook: step the debris without waiting for frames
   reset() {
     introDone(); autoplayAt = 0;
     if (mode === 'overview') flyTo(...overview(), 1.4);

damage.js

@@ -211,9 +211,16 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT }) {
   const fPos = new Float32Array(FMAX * 3), fVel = new Float32Array(FMAX * 3), fRot = new Float32Array(FMAX * 3), fSpin = new Float32Array(FMAX * 3);
   const fSize = new Float32Array(FMAX), fAge = new Float32Array(FMAX), fRest = new Uint8Array(FMAX), fLive = new Uint8Array(FMAX);
   let fHead = 0;
+  // Settle rule: nothing may hang still where it is drawn. In the rolled view the floor is not drawn, so a piece
+  // resting on it reads as hanging in mid-air; landed pieces therefore fade out soon after they land, and a
+  // watchdog retires anything that has been drawn without moving for STILL_MAX seconds.
+  const REST_HOLD = 1.0, REST_FADE = 1.2, STILL_MAX = 2.5;
+  const fRestT = new Float32Array(FMAX), fStill = new Float32Array(FMAX), fLast = new Float32Array(FMAX * 3), pStill = new Float32Array(PMAX);
+  let auditMax = 0, auditAir = 0, retired = 0;
+  const hide = (i) => { tmpM.makeScale(0, 0, 0); fMesh.setMatrixAt(i, tmpM); };
   function spawnF(x, y, z, vx, vy, vz, size) {
     const i = fHead++ % FMAX;
-    fLive[i] = 1; fRest[i] = 0; fAge[i] = 0; fSize[i] = size;
+    fLive[i] = 1; fRest[i] = 0; fAge[i] = 0; fSize[i] = size; fRestT[i] = 0; fStill[i] = 0;
     fPos[i * 3] = x; fPos[i * 3 + 1] = y; fPos[i * 3 + 2] = z;
     fVel[i * 3] = vx; fVel[i * 3 + 1] = vy; fVel[i * 3 + 2] = vz;
     for (let c = 0; c < 3; c++) { fRot[i * 3 + c] = Math.random() * 6.3; fSpin[i * 3 + c] = (Math.random() - 0.5) * 14; }
@@ -366,20 +373,27 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT }) {
         if (t === 2 || t === 4) { pCol[i * 4 + 3] = 0; continue; }
         // dust and ash land: snap to the floor, stop, sleep
         pPos[o + 1] = G + 0.05; pVel[o] = pVel[o + 1] = pVel[o + 2] = 0; pSleep[i] = 1;
-        pLife[i] = pAge[i] + 6 + Math.random() * 4;
+        pLife[i] = pAge[i] + REST_HOLD + REST_FADE + Math.random() * 0.5;
         continue;
       }
       if (t === 2) { pSize[i] += dt * 2.6; pCol[i * 4 + 3] = 0.42 * fade * Math.min(1, pAge[i] * 2); }
       else if (t === 4) pCol[i * 4 + 3] = fade;
       else if (t !== 3) pCol[i * 4 + 3] = Math.min(0.8, fade * 1.6) * (t === 0 ? 0.75 : 0.9);
     }
+    // watchdog for particles: visible, not asleep on the floor, and not moving
+    for (let i = 0; i < PMAX; i++) {
+      if (pCol[i * 4 + 3] <= 0 || pSleep[i]) { pStill[i] = 0; continue; }
+      const sp = Math.abs(pVel[i * 3]) + Math.abs(pVel[i * 3 + 1]) + Math.abs(pVel[i * 3 + 2]);
+      pStill[i] = sp < 0.05 ? pStill[i] + dt : 0;
+      if (pStill[i] > STILL_MAX) { pCol[i * 4 + 3] = 0; pStill[i] = 0; retired++; }
+    }
     pGeo.attributes.position.needsUpdate = pGeo.attributes.aCol.needsUpdate = pGeo.attributes.aSize.needsUpdate = true;
     // fragments flutter and tumble with lift; big flakes drop
     for (let i = 0; i < fMesh.count; i++) {
       const o = i * 3;
-      if (!fLive[i]) { tmpM.makeScale(0, 0, 0); fMesh.setMatrixAt(i, tmpM); continue; }
+      if (!fLive[i]) { hide(i); continue; }
       fAge[i] += dt;
-      if (!Number.isFinite(fPos[o] + fPos[o + 1] + fPos[o + 2])) { fLive[i] = 0; continue; }
+      if (!Number.isFinite(fPos[o] + fPos[o + 1] + fPos[o + 2] + fVel[o] + fVel[o + 1] + fVel[o + 2] + fRot[o] + fRot[o + 1] + fRot[o + 2])) { fLive[i] = 0; hide(i); continue; }
       if (!fRest[i]) {
         const big = fSize[i] > 1.0;
         const g = big ? 380 : 160, k = big ? 0.6 : 3.0;
@@ -391,8 +405,10 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT }) {
         for (let c = 0; c < 3; c++) { fPos[o + c] += fVel[o + c] * dt; fRot[o + c] += fSpin[o + c] * dt; }
         if (fPos[o + 1] < ground() + 0.1) { fPos[o + 1] = ground() + 0.1; fRest[i] = 1; fRot[o] = Math.PI / 2 + (Math.random() - 0.5) * 0.3; }
       }
-      const fadeS = fAge[i] > 25 ? Math.max(0, 1 - (fAge[i] - 25) / 5) : 1;
-      if (fadeS <= 0) fLive[i] = 0;
+      // landed: lie a moment, then fade; airborne pieces still fade by age as a backstop
+      if (fRest[i]) fRestT[i] += dt;
+      const fadeS = Math.min(fAge[i] > 25 ? 1 - (fAge[i] - 25) / 5 : 1, fRest[i] ? 1 - (fRestT[i] - REST_HOLD) / REST_FADE : 1, 1);
+      if (fadeS <= 0) { fLive[i] = 0; hide(i); continue; }
       tmpE.set(fRot[o], fRot[o + 1], fRot[o + 2]);
       tmpQ.setFromEuler(tmpE);
       tmpS.setScalar(fSize[i] * fadeS);
@@ -400,6 +416,7 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT }) {
       tmpM.compose(tmpP, tmpQ, tmpS);
       fMesh.setMatrixAt(i, tmpM);
     }
+    audit(dt);
     fMesh.instanceMatrix.needsUpdate = true;
     // puddles spread and slowly soak away
     const G2 = ground() + 0.05;
@@ -414,18 +431,38 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT }) {
     qMesh.instanceMatrix.needsUpdate = true;
   }
 
+  // Audit what is actually drawn, from the instance matrices themselves, so a stale or orphaned slot counts too:
+  // a slot with a visible scale whose position has not changed. Past STILL_MAX it is hidden and freed.
+  function audit(dt) {
+    const a = fMesh.instanceMatrix.array, G = ground();
+    let mx = 0, air = 0;
+    for (let i = 0; i < FMAX; i++) {
+      const j = i * 16, o = i * 3;
+      const drawn = i < fMesh.count && a[j] * a[j] + a[j + 1] * a[j + 1] + a[j + 2] * a[j + 2] > 1e-8;
+      const moved = Math.abs(a[j + 12] - fLast[o]) + Math.abs(a[j + 13] - fLast[o + 1]) + Math.abs(a[j + 14] - fLast[o + 2]) > 1e-4;
+      fLast[o] = a[j + 12]; fLast[o + 1] = a[j + 13]; fLast[o + 2] = a[j + 14];
+      fStill[i] = drawn && !moved && dt > 0 ? fStill[i] + dt : drawn && !moved ? fStill[i] : 0;
+      if (fStill[i] > STILL_MAX) { fLive[i] = 0; hide(i); fStill[i] = 0; retired++; continue; }
+      if (fStill[i] > mx) mx = fStill[i];
+      if (fStill[i] > 0 && a[j + 13] > G + 0.5) air = Math.max(air, fStill[i]);
+    }
+    auditMax = Math.max(auditMax, mx); auditAir = Math.max(auditAir, air);
+  }
   function reset() {
     for (const k of masks.values()) { own(k.m).uDmgOn.value = 0; own(k.m).uDmg.value = blankTex; k.tex.dispose(); }
     masks.clear();
     emberCount = 0;
-    pCol.fill(0); fLive.fill(0); fMesh.count = 0; fHead = 0; puddles.length = 0; qMesh.count = 0;
+    pCol.fill(0); fLive.fill(0); pStill.fill(0); fStill.fill(0);
+    for (let i = 0; i < FMAX; i++) hide(i);   // no stale matrices left in the pool
+    fMesh.instanceMatrix.needsUpdate = true; fMesh.count = 0; fHead = 0; puddles.length = 0; qMesh.count = 0;
   }
   const blankTex = new THREE.DataTexture(new Uint8Array(4), 1, 1); blankTex.needsUpdate = true;
   const belowFloor = () => { const G = ground(); let n = 0, sleeping = 0; for (let i = 0; i < PMAX; i++) if (pCol[i * 4 + 3] > 0) { if (pPos[i * 3 + 1] < G - 0.01) n++; if (pSleep[i]) sleeping++; } return { n, sleeping }; };
-  const stats = () => ({ floor: belowFloor(), masks: masks.size, embers: emberCount, particles: [...pCol].filter((_, i) => i % 4 === 3).filter((a) => a > 0).length, shards: fLive.reduce((a, b) => a + b, 0), puddles: puddles.length });
+  const stats = () => ({ floor: belowFloor(), masks: masks.size, embers: emberCount, particles: [...pCol].filter((_, i) => i % 4 === 3).filter((a) => a > 0).length, shards: fLive.reduce((a, b) => a + b, 0), puddles: puddles.length,
+    stillMax: +auditMax.toFixed(2), stillAirMax: +auditAir.toFixed(2), retired });
   // map a material-space hit (mm) from the flat sandbox onto the same mask
   function crushMM(m, xMM, yMM, rMM) { const w = m.userData.w; crush(m, xMM / w.widthMM, yMM / w.heightMM, rMM, 1.0); }
   function tearMM(m, ax, ay, bx, by) { const w = m.userData.w; const k = mask(m); line(k, ax / w.widthMM, ay / w.heightMM, bx / w.widthMM, by / w.heightMM, 0.28, 0, 0.75, 0.3); line(k, ax / w.widthMM, ay / w.heightMM, bx / w.widthMM, by / w.heightMM, 0.8, 1, 0.3, 0.4); }
   const objects = [points, fMesh, qMesh];
-  return { objects, shared, blankTex, bruise, crush, tear, wetAt, ignite, debris, drops, update, reset, stats, crushMM, tearMM, wetness: (m, u, v) => (masks.has(m) ? at(masks.get(m), u, v, 3) : 0), dust: (x, y, z) => debris({ x, y, z }, 1.5, 0, 'tear') || spawnP(0, x, y, z, (Math.random() - 0.5) * 30, 8 + Math.random() * 12, 8 + Math.random() * 15, 0.3 + Math.random() * 0.4, 6, 0.13, 0.1, 0.08, 0.75) };
+  return { objects, shared, blankTex, bruise, crush, tear, wetAt, ignite, debris, drops, update, reset, stats, simulate: (n, dt) => { for (let i = 0; i < n; i++) update(dt, shared.uDmgT.value + dt, dt); return stats(); }, crushMM, tearMM, wetness: (m, u, v) => (masks.has(m) ? at(masks.get(m), u, v, 3) : 0), dust: (x, y, z) => debris({ x, y, z }, 1.5, 0, 'tear') || spawnP(0, x, y, z, (Math.random() - 0.5) * 30, 8 + Math.random() * 12, 8 + Math.random() * 15, 0.3 + Math.random() * 0.4, 6, 0.13, 0.1, 0.08, 0.75) };
 }