Realism pass for carbonized papyrus, island and outlier prune for unroll morph, docs/REALISM.md, cache bust d

README.md

@@ -46,6 +46,8 @@ Just for fun, not a real unrolling. Press **Destroy** (T) to tear (X), crush (C)
 
 **Crumble** (K, or `unrollView.crumble()` in the console) breaks the whole scroll up from its edges inward over about four seconds; the pieces are pulled in toward the middle and fall into a heap of dust on the floor. **Reset** restores the scroll and clears all damage, debris and the heap. Particle and fragment counts stay capped (about 1,800 particles, 600 fragments and 2,600 heap grains on desktop, less on phones).
 
+Why the tools behave as they do, with sources: [docs/REALISM.md](docs/REALISM.md).
+
 For testing, `unrollView.damageStats()` reports the counts, the floor height, `stillAirMax` (longest any debris hung still above the floor, should stay 0) and `stillMax`.
 
 ## Rebuilding the data

app.js

@@ -4,12 +4,12 @@ import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
 import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
 import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';
 import { OutputPass } from 'three/addons/postprocessing/OutputPass.js';
-import { createTear } from './tear.js?v=20261016b';
+import { createTear } from './tear.js?v=20261016g';
 import { loadRegistry, listLocal, getLocal, localKey, remoteSource, fileSource, findManifest, buildMeshScroll, decodeImage } from './lib/scrolls.js';
 import { validateManifest, peelOrder, layerWindings, layerFile, roleOf, fill, REGISTRY_LIMITS, LOCAL_LIMITS } from './lib/manifest.js';
 import { setupOpenOwn } from './lib/openown.js';
 import { unpackInt16 } from './lib/formats.js';
-import { createDamage, injectFrag, DMG_HEAD } from './damage.js?v=20261016b';
+import { createDamage, injectFrag, DMG_HEAD } from './damage.js?v=20261016g';
 
 const $ = (id) => document.getElementById(id);
 const params = new URLSearchParams(location.hash.slice(1));
@@ -345,7 +345,8 @@ void main() {
   vec3 p = mix(pc, pf, e);
   p.z -= sin(3.14159265 * e) * uLift;
   // soaked papyrus softens and sags
-  if (uDmgOn > 0.5) { float wv = texture2D(uDmg, aLocal).a; p.y -= wv * wv * 1.8; p.z += wv * 0.6; }
+  // soaked charcoal swells a little and slumps where it turns to mush; it does not sag like wet paper
+  if (uDmgOn > 0.5) { float wv = texture2D(uDmg, aLocal).a; p.z += wv * 0.35; p.y -= wv * wv * 0.35; }
   vN = normalize(mix(nc, vec3(0.0, 0.0, 1.0), e));
   vLocal = aLocal;
   vE = e;
@@ -432,11 +433,39 @@ const meshes = [];
 const decim = MOBILE ? 2 : 1;
 let Rmax = 0;
 
+// Keep only the real sheet: drop triangle islands (connected through shared vertices) that are tiny next to the
+// largest piece of the winding. Such islands are stray bits of the trace, often above the top edge, that float
+// free of the sheet once it is unrolled flat. The vertices themselves are untouched, so every kept triangle maps
+// rolled to flat exactly as before.
+function pruneIslands(index, nVerts, id, minFrac = 0.02, minTris = 120) {
+  const nt = index.length / 3, parent = new Int32Array(nVerts);
+  for (let i = 0; i < nVerts; i++) parent[i] = i;
+  const find = (x) => { while (parent[x] !== x) { parent[x] = parent[parent[x]]; x = parent[x]; } return x; };
+  for (let t = 0; t < nt; t++) {
+    const a = find(index[t * 3]), b = find(index[t * 3 + 1]), c = find(index[t * 3 + 2]);
+    if (a !== b) parent[a] = b;
+    const b2 = find(b); if (find(c) !== b2) parent[find(c)] = b2;
+  }
+  const count = new Map();
+  for (let t = 0; t < nt; t++) { const r = find(index[t * 3]); count.set(r, (count.get(r) || 0) + 1); }
+  let big = 0; for (const v of count.values()) big = Math.max(big, v);
+  const keepMin = Math.min(big, Math.max(minTris, big * minFrac));
+  const out = [];
+  let dropped = 0;
+  for (let t = 0; t < nt; t++) {
+    if (count.get(find(index[t * 3])) >= keepMin) out.push(index[t * 3], index[t * 3 + 1], index[t * 3 + 2]);
+    else dropped++;
+  }
+  islandStats.dropped += dropped; islandStats.kept += out.length / 3;
+  if (dropped) islandStats.windings[id] = dropped;
+  return out;
+}
+const islandStats = { dropped: 0, kept: 0, windings: {}, opened: {} };
 function meshGeometry(w) {
   const geo = new THREE.BufferGeometry();
   geo.setAttribute('position', new THREE.BufferAttribute(w.pos, 3));
   geo.setAttribute('aLocal', new THREE.BufferAttribute(w.loc, 2));
-  geo.setIndex(new THREE.BufferAttribute(w.index, 1));
+  geo.setIndex(pruneIslands(w.index, w.loc.length / 2, w.id));
   geo.computeVertexNormals();
   geo.computeBoundingSphere();
   return { geo, ytop: w.ytop, colAng: w.colAng };
@@ -506,6 +535,31 @@ function gridGeometry(w) {
     }
     solid[r * C + c] = n >= 6 ? 1 : 0;
   }
+  // morphological opening (erode to points with at least 8 of their 9 neighbours, grow back one step): spikes and
+  // hairlines one or two samples wide, which the trace ran off the real edge, are removed; the sheet keeps its shape
+  const OPEN = 9;
+  {
+    const er = new Uint8Array(R * C);
+    for (let r = 0; r < R; r++) for (let c = 0; c < C; c++) {
+      if (!solid[r * C + c]) continue;
+      let n = 0;
+      for (let dr = -decim; dr <= decim; dr += decim) for (let dc = -decim; dc <= decim; dc += decim) {
+        const rr = r + dr, cc = c + dc;
+        if (rr >= 0 && cc >= 0 && rr < R && cc < C && solid[rr * C + cc]) n++;
+      }
+      er[r * C + c] = n >= OPEN ? 1 : 0;
+    }
+    for (let r = 0; r < R; r++) for (let c = 0; c < C; c++) {
+      if (!solid[r * C + c]) continue;
+      let any = 0;
+      for (let dr = -decim; dr <= decim && !any; dr += decim) for (let dc = -decim; dc <= decim; dc += decim) {
+        const rr = r + dr, cc = c + dc;
+        if (rr >= 0 && cc >= 0 && rr < R && cc < C && er[rr * C + cc]) { any = 1; break; }
+      }
+      if (!any) { const q = islandStats.opened[w.id] || (islandStats.opened[w.id] = { n: 0, u: 0, v: 1 }); q.n++; if (loc[(r * C + c) * 2 + 1] < q.v) { q.v = +loc[(r * C + c) * 2 + 1].toFixed(3); q.u = +loc[(r * C + c) * 2].toFixed(3); } }
+      solid[r * C + c] = any;
+    }
+  }
   const ok = (p, q, r) => solid[p] && solid[q] && solid[r] && d2(p, q) < t2 && d2(q, r) < t2 && d2(p, r) < t2;
   for (let r = 0; r + decim < R; r += decim) {
     for (let c = 0; c + decim < C; c += decim) {
@@ -517,7 +571,7 @@ function gridGeometry(w) {
   const geo = new THREE.BufferGeometry();
   geo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
   geo.setAttribute('aLocal', new THREE.BufferAttribute(loc, 2));
-  geo.setIndex(idx);
+  geo.setIndex(pruneIslands(idx, R * C, w.id));
   geo.computeVertexNormals();
   geo.computeBoundingSphere();
   return { geo, ytop, colAng };
@@ -613,7 +667,7 @@ function sheetBottom() {
     if (p < 1) lo = Math.min(lo, rolledMin + shared.uRoll.value.y);
     if (p > 0) lo = Math.min(lo, flatMin);
   }
-  return lo - 1.8;   // soaked papyrus sags up to 1.8 mm
+  return lo - 0.4;   // soaked papyrus slumps a little
 }
 let groundY = NaN;
 function updateGround(dt) {
@@ -1466,6 +1520,37 @@ window.unrollView = {
   introActive: () => intro,
   skipIntro: () => { if (!intro) return false; introDone(); autoplayAt = performance.now() + 150; $('skipIntro')?.remove(); return true; },
   damageStats: () => damage.stats(),
+  viewFlat: (id, u, v, d = 40, tt = null) => { const m = meshes.find((q) => q.userData.w.id === id); if (!m) return null; const { start, w, own } = m.userData; const x = tt ?? Math.min(1, (start + w.widthMM) / L + 0.004); introDone(); autoplayAt = 0; setPlaying(false); t = tShown = x; setTarget(x, 'hash'); applyT(x, 0); mode = 'shot'; fly = null; const F = own.uFlatO.value; controls.target.set(F.x + u * w.widthMM, F.y - v * w.heightMM, F.z); camera.position.copy(controls.target).add(new THREE.Vector3(0, -d * 0.15, d)); controls.update(); return x; },
+  islandStats: () => islandStats,
+  setT: (x) => { introDone(); autoplayAt = 0; setPlaying(false); t = tShown = x; setTarget(x, 'hash'); const st = applyT(x, 0); const f = framing(st); controls.target.copy(f); camera.position.copy(f).add(rollOffset()); fly = null; return st.cur.userData.w.id; },
+  // test hook: the worst stretch of any triangle mid-unroll, relative to its rolled and flat size (1 = none)
+  morphAudit: (lim = 4) => { const out = { tot: 0, bad: 0, worst: 0, ex: [] }, c = Math.cos(shared.uRot.value), sn = Math.sin(shared.uRot.value), q = new Float32Array(9);
+    for (const m of meshes) { const g = m.geometry, P = g.attributes.position.array, A = g.attributes.aLocal.array, I = g.index.array, own = m.userData.own, W = own.uSize.value.x, H = own.uSize.value.y, F = own.uFlatO.value, soft = own.uSoft.value;
+      for (let t = 0; t < I.length; t += 3) { out.tot++;
+        const uc = (A[I[t] * 2] + A[I[t + 1] * 2] + A[I[t + 2] * 2]) / 3, uP = (uc + 0.5 * soft) / (1 + soft), Rx = m.userData.start + uP * W, Rz = 0;
+        let base = 0, mo = 0;
+        for (let v = 0; v < 3; v++) { const i = I[t + v], u = A[i * 2], vv = A[i * 2 + 1];
+          const e0 = Math.min(1, Math.max(0, (uP * (1 + soft) - u) / soft)), e = e0 * e0 * (3 - 2 * e0);
+          const cx = P[i * 3] * c + P[i * 3 + 2] * sn + Rx, cy = P[i * 3 + 1], cz = -P[i * 3] * sn + P[i * 3 + 2] * c + Rz;
+          const fx = F.x + u * W, fy = F.y - vv * H, fz = F.z;
+          q[v * 3] = cx + (fx - cx) * e; q[v * 3 + 1] = cy + (fy - cy) * e; q[v * 3 + 2] = cz + (fz - cz) * e - Math.sin(Math.PI * e) * shared.uLift.value; }
+        for (let e = 0; e < 3; e++) { const a = I[t + e], b = I[t + (e + 1) % 3], f = (e + 1) % 3;
+          base = Math.max(base, Math.hypot(P[a * 3] - P[b * 3], P[a * 3 + 1] - P[b * 3 + 1], P[a * 3 + 2] - P[b * 3 + 2]), Math.hypot((A[a * 2] - A[b * 2]) * W, (A[a * 2 + 1] - A[b * 2 + 1]) * H));
+          mo = Math.max(mo, Math.hypot(q[e * 3] - q[f * 3], q[e * 3 + 1] - q[f * 3 + 1], q[e * 3 + 2] - q[f * 3 + 2])); }
+        const r = mo / (base + 0.05);
+        if (r > out.worst) out.worst = r;
+        if (mo > lim && r > 3) { out.bad++; if (out.ex.length < 6) out.ex.push([m.userData.w.id, t / 3, +mo.toFixed(1), +base.toFixed(2), +uc.toFixed(3)]); } } }
+    out.worst = +out.worst.toFixed(1); return out; },
+  // test hook: triangles whose flat (unrolled) size is far from their rolled size stretch into spikes while unrolling
+  geomAudit: (ratio = 3) => { let bad = 0, worst = 0, tot = 0; const ex = [];
+    for (const m of meshes) { const g = m.geometry, P = g.attributes.position.array, A = g.attributes.aLocal.array, I = g.index.array, W = m.userData.w.widthMM, H = m.userData.w.heightMM;
+      for (let t = 0; t < I.length; t += 3) { tot++; let rf = 0;
+        for (let e = 0; e < 3; e++) { const a = I[t + e], b = I[t + (e + 1) % 3];
+          const d3 = Math.hypot(P[a * 3] - P[b * 3], P[a * 3 + 1] - P[b * 3 + 1], P[a * 3 + 2] - P[b * 3 + 2]);
+          const df = Math.hypot((A[a * 2] - A[b * 2]) * W, (A[a * 2 + 1] - A[b * 2 + 1]) * H);
+          rf = Math.max(rf, (Math.max(d3, df) + 0.05) / (Math.min(d3, df) + 0.05)); }
+        if (rf > ratio) { bad++; if (ex.length < 5) ex.push([m.userData.w.id, t / 3, +rf.toFixed(1)]); } worst = Math.max(worst, rf); } }
+    return { tot, bad, worst: +worst.toFixed(1), ex }; },
   sandboxStats: () => (tear ? tear.stats() : null),
   sandboxSim: (n) => { if (!tear) return null; for (let i = 0; i < n; i++) { tear.step(1 / 60); damage.update(1 / 60, shared.uTime.value += 1 / 60, 1 / 60); } return tear.stats(); },
   crumble: () => crumble(),   // owner feature: crumble the whole scroll to dust; Reset restores it

damage.js

@@ -55,13 +55,13 @@ export const DMG_EDGE = /* glsl */`
     col *= 1.0 - 0.45 * smoothstep(0.1, 0.5, dd.g);
     float crack = dd.g * smoothstep(0.35, 0.75, dFibV + dd.g * 0.35);
     col = mix(col, vec3(0.010, 0.007, 0.005) * (0.6 + 0.8 * dFibV), clamp(charK * 0.97 + crack * 0.9, 0.0, 1.0));
+    // wet charcoal: soaks up the water and goes matt black-brown, no sheen
     float wet = dd.a;
-    col *= 1.0 - 0.8 * wet;
-    vec3 dH = normalize(normalize(vec3(-0.35, 0.75, 0.55)) + normalize(cameraPosition - vW));
-    col += wet * (pow(abs(dot(normalize(vN), dH)), 40.0) * vec3(0.9, 0.85, 0.78) + pow(1.0 - abs(dot(normalize(vN), normalize(cameraPosition - vW))), 4.0) * vec3(0.12, 0.12, 0.13));
-    float flick = 0.7 + 0.3 * sin(uDmgT * 2.3 + dFibV * 23.0) * sin(uDmgT * 1.1 + dFibV * 7.0);
+    col = mix(col, col * vec3(0.16, 0.13, 0.11), smoothstep(0.0, 0.7, wet));
+    // smouldering charcoal: a dim, slowly breathing deep orange in the char band, no flame
+    float flick = 0.75 + 0.25 * sin(uDmgT * 0.9 + dFibV * 23.0) * sin(uDmgT * 0.43 + dFibV * 7.0);
     float emb = dd.b * flick;
-    col += vec3(1.0, 0.30, 0.05) * emb * (0.6 + 2.0 * charK) * 1.6;
+    col += vec3(0.85, 0.22, 0.04) * emb * emb * (0.25 + 1.1 * charK) * 0.9;
   }
 `;
 export function injectFrag(frag, cutAfter) {
@@ -192,6 +192,7 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
   const pPos = new Float32Array(PMAX * 3), pVel = new Float32Array(PMAX * 3), pCol = new Float32Array(PMAX * 4), pSize = new Float32Array(PMAX);
   const pSleep = new Uint8Array(PMAX), pType = new Uint8Array(PMAX), pLife = new Float32Array(PMAX), pAge = new Float32Array(PMAX), pSeed = new Float32Array(PMAX);
   let pHead = 0;
+  const pA0 = new Float32Array(PMAX);   // spawn opacity: fades scale from it, so faint smoke stays faint
   const pGeo = new THREE.BufferGeometry();
   pGeo.setAttribute('position', new THREE.BufferAttribute(pPos, 3).setUsage(THREE.DynamicDrawUsage));
   pGeo.setAttribute('aCol', new THREE.BufferAttribute(pCol, 4).setUsage(THREE.DynamicDrawUsage));
@@ -214,7 +215,7 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
     pSleep[i] = 0; pType[i] = type; pPos[i * 3] = x; pPos[i * 3 + 1] = y; pPos[i * 3 + 2] = z;
     pVel[i * 3] = vx; pVel[i * 3 + 1] = vy; pVel[i * 3 + 2] = vz;
     pSize[i] = size; pLife[i] = life; pAge[i] = 0; pSeed[i] = Math.random() * 100;
-    pCol[i * 4] = r; pCol[i * 4 + 1] = g; pCol[i * 4 + 2] = b; pCol[i * 4 + 3] = a;
+    pCol[i * 4] = r; pCol[i * 4 + 1] = g; pCol[i * 4 + 2] = b; pCol[i * 4 + 3] = a; pA0[i] = a;
   }
   // fragments and flakes: tumbling instanced shards
   const FMAX = MOBILE ? 220 : 600;
@@ -225,7 +226,7 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
     const idx = []; for (let i = 1; i <= n; i++) idx.push(0, i, i + 1);
     shard.setAttribute('position', new THREE.Float32BufferAttribute(v, 3)); shard.setIndex(idx); shard.computeVertexNormals();
   }
-  const fMesh = new THREE.InstancedMesh(shard, new THREE.MeshStandardMaterial({ color: 0x2a1d14, roughness: 0.9, metalness: 0, side: THREE.DoubleSide }), FMAX);
+  const fMesh = new THREE.InstancedMesh(shard, new THREE.MeshStandardMaterial({ color: 0x15110e, roughness: 0.95, metalness: 0, side: THREE.DoubleSide }), FMAX);
   fMesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
   fMesh.frustumCulled = false;
   fMesh.count = 0;
@@ -253,7 +254,7 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
   // puddles on the floor
   const QMAX = 40;
   const qMesh = new THREE.InstancedMesh(new THREE.CircleGeometry(1, 28).rotateX(-Math.PI / 2),
-    new THREE.MeshStandardMaterial({ color: 0x0b0d10, roughness: 0.08, metalness: 0.2, transparent: true, opacity: 0.85 }), QMAX);
+    new THREE.MeshStandardMaterial({ color: 0x0a0807, roughness: 0.7, metalness: 0, transparent: true, opacity: 0.9 }), QMAX);   // black sludge
   qMesh.frustumCulled = false; qMesh.count = 0;
   scene.add(qMesh);
   const puddles = [];
@@ -268,17 +269,17 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
     const { x, y, z } = world;
     for (let i = 0; i < n; i++) {
       const a = Math.random() * 6.283, r = Math.random() * rMM;
-      const big = Math.random() < 0.25;
+      const big = Math.random() < 0.1;   // charcoal powders: a few flakes, mostly small bits
       spawnF(x + Math.cos(a) * r, y + Math.sin(a) * r * 0.6, z + 0.4,
-        Math.cos(a) * (20 + Math.random() * 50), 10 + Math.random() * 40, 20 + Math.random() * 50,
-        big ? 1.1 + Math.random() * 1.5 : 0.35 + Math.random() * 0.6);
+        Math.cos(a) * (6 + Math.random() * 16), 2 + Math.random() * 10, 6 + Math.random() * 16,
+        big ? 0.9 + Math.random() * 1.0 : 0.25 + Math.random() * 0.45);
     }
-    const nd = kind === 'tear' ? n * 2 : n * 5;
+    const nd = kind === 'tear' ? n * 4 : n * 10;
     for (let i = 0; i < nd; i++) {
-      const a = Math.random() * 6.283, sp = 15 + Math.random() * 35;   // a little puff outward
-      const c = 0.10 + Math.random() * 0.06;
+      const a = Math.random() * 6.283, sp = 6 + Math.random() * 18;   // a soft puff of black dust
+      const c = 0.035 + Math.random() * 0.035;
       spawnP(0, x + (Math.random() - 0.5) * rMM, y + (Math.random() - 0.5) * rMM, z + 0.5,
-        Math.cos(a) * sp, Math.sin(a) * sp * 0.6 + 6, 8 + Math.random() * 25, 0.25 + Math.random() * 0.5, 5 + Math.random() * 4, c * 1.25, c * 0.95, c * 0.75, 0.75);
+        Math.cos(a) * sp, Math.sin(a) * sp * 0.6 + 3, 4 + Math.random() * 10, 0.25 + Math.random() * 0.5, 10 + Math.random() * 6, c * 1.15, c, c * 0.9, 0.8);
     }
   }
   function drops(world, n) {
@@ -338,7 +339,7 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
     const top = cr.H * (0.3 + 0.7 * f) * Math.pow(Math.max(0, 1 - r / cr.R), 1.6);
     hH[i] = top * Math.pow(Math.random(), 0.6) + 0.2;
     hPos[i * 3] = cr.cx + Math.cos(a) * r; hPos[i * 3 + 2] = cr.cz + Math.sin(a) * r * 0.85;
-    const c = 0.06 + Math.random() * 0.12, warm = Math.random() < 0.15 ? 0.05 : 0;
+    const c = 0.03 + Math.random() * 0.07, warm = Math.random() < 0.1 ? 0.02 : 0;
     hCol[i * 4] = c * 1.3 + warm; hCol[i * 4 + 1] = c; hCol[i * 4 + 2] = c * 0.75; hCol[i * 4 + 3] = 0;
     hSize[i] = 0.9 + Math.random() * 1.4 + (1 - r / cr.R) * 0.8;   // coarser in the core
   }
@@ -365,7 +366,7 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
         const ix = cr.cx - cP.x, iz = cr.cz - cP.z, il = Math.hypot(ix, iz) || 1, pull = 25 + Math.random() * 45;
         if (q < nF) spawnF(cP.x, cP.y, cP.z, ix / il * pull, Math.random() * 15, iz / il * pull, 0.35 + Math.random() * (Math.random() < 0.2 ? 1.6 : 0.6));
         else {
-          const c = 0.09 + Math.random() * 0.07;
+          const c = 0.035 + Math.random() * 0.04;
           spawnP(0, cP.x, cP.y, cP.z, ix / il * pull * 0.6, 4 + Math.random() * 10, iz / il * pull * 0.6, 0.3 + Math.random() * 0.5, 3 + Math.random() * 2, c * 1.25, c * 0.95, c * 0.75, 0.75);
         }
       }
@@ -402,7 +403,7 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
           blob(k, e.u, e.v, 2.6, 2, Math.min(1, 0.05 * q));
           blob(k, e.u, e.v, 0.8, 0, Math.min(1, (e.age > 1.2 ? 0.05 : 0.01) * q));
           for (let rep = 0; rep < 3 && e.next <= 0 && e.gen < 40; rep++) {
-            e.next += 0.25 + Math.random() * 0.45;
+            e.next += 0.6 + Math.random() * 1.0;   // smouldering creeps slowly
             const along = Math.random() < 0.7, s = 0.6 + Math.random() * 0.8, a = Math.random() < 0.5 ? -1 : 1;
             const [du, dv] = mmToUV(k, along ? a * s * 1.9 : (Math.random() - 0.5) * s * 1.4, along ? (Math.random() - 0.5) * s * 0.6 : a * s * 1.0);
             if (Math.random() < 0.97 - e.gen * 0.01) addEmber(k, e.u + du, e.v + dv, e.gen + 1);
@@ -421,11 +422,11 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
           for (let i = 0; i < Math.min(3, keep.length / 6 + 1); i++) {
             const g = 0.16 + Math.random() * 0.1;
             if (pick()) spawnP(2, sp.x, sp.y, sp.z,
-              (Math.random() - 0.5) * 6 + sn.x * 4, 8 + Math.random() * 6, (Math.random() - 0.5) * 4 + sn.z * 4, 3 + Math.random() * 3, 4 + Math.random() * 3, g * 1.8, g * 1.75, g * 1.7, 0.5);
+              (Math.random() - 0.5) * 6 + sn.x * 4, 8 + Math.random() * 6, (Math.random() - 0.5) * 4 + sn.z * 4, 3 + Math.random() * 3, 4 + Math.random() * 3, g * 1.8, g * 1.75, g * 1.7, 0.22);
           }
           if (Math.random() < 0.6 && pick()) spawnP(1, sp.x, sp.y, sp.z,
-            (Math.random() - 0.5) * 8 + sn.x * 3, 12 + Math.random() * 10, sn.z * 3, 0.5 + Math.random() * 0.6, 6, 0.32, 0.30, 0.28, 0.85);
-          if (Math.random() < 0.25 && pick()) spawnP(4, sp.x, sp.y, sp.z, (Math.random() - 0.5) * 10 + sn.x * 6, 25 + Math.random() * 15, sn.z * 6, 0.25, 1.2, 1.0, 0.45, 0.1, 1.0);
+            (Math.random() - 0.5) * 8 + sn.x * 3, 12 + Math.random() * 10, sn.z * 3, 0.4 + Math.random() * 0.5, 8, 0.58, 0.56, 0.53, 0.8);   // light grey ash
+          if (Math.random() < 0.02 && pick()) spawnP(4, sp.x, sp.y, sp.z, (Math.random() - 0.5) * 10 + sn.x * 6, 25 + Math.random() * 15, sn.z * 6, 0.18, 0.7, 0.8, 0.3, 0.06, 0.7);   // a rare dull spark
         }
       }
     }
@@ -450,8 +451,13 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
         if (w.t < 2.5 || at(k, w.u, w.v, 3) < 0.55 || Math.random() > 0.35) continue;
         const a = Math.random() * 6.283, r = Math.random() * w.r * 0.8;
         const [du, dv] = mmToUV(k, Math.cos(a) * r, Math.sin(a) * r);
-        blob(k, w.u + du, w.v + dv, 0.5 + Math.random() * 0.6, 0, 0.12);
-        if (Math.random() < 0.3) blob(k, w.u + du, w.v + dv, 1.2, 1, 0.15);
+        blob(k, w.u + du, w.v + dv, 0.5 + Math.random() * 0.6, 0, 0.2);
+        if (Math.random() < 0.5) blob(k, w.u + du, w.v + dv, 1.2, 1, 0.2);   // layers lift apart along the fibres
+        // the mush lets go: black sludge drips and a few sodden fragments drop from where it is on the sheet
+        if (surfacePoint && surfacePoint(k.m, w.u + du, w.v + dv, sp)) {
+          spawnP(3, sp.x, sp.y - 0.3, sp.z + 0.2, (Math.random() - 0.5) * 3, -4, 0, 0.9 + Math.random() * 0.6, 4, 0.05, 0.04, 0.035, 0.95);
+          if (Math.random() < 0.35) spawnF(sp.x, sp.y, sp.z + 0.2, (Math.random() - 0.5) * 4, -2, 1, 0.3 + Math.random() * 0.5);
+        }
       }
     }
     // texture uploads, throttled
@@ -476,7 +482,7 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
         continue;
       }
       let g, k, turb;
-      if (t === 0) { g = 22; k = 3.2; turb = 10; }          // dust: terminal velocity about 7 mm/s
+      if (t === 0) { g = 9; k = 3.6; turb = 8; }            // charcoal dust, very light: settles at about 2.5 mm/s
       else if (t === 1) { g = 6; k = 1.6; turb = 12; }      // ash: warm air carries it up first
       else if (t === 2) { g = -14; k = 1.1; turb = 14; }    // smoke rises
       else if (t === 3) { g = 520; k = 0.3; turb = 0; }     // water drops
@@ -501,8 +507,8 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
         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;
+      if (t === 2) { pSize[i] += dt * 2.6; pCol[i * 4 + 3] = pA0[i] * 0.84 * fade * Math.min(1, pAge[i] * 2); }
+      else if (t === 4) pCol[i * 4 + 3] = fade * pA0[i];
       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
@@ -590,5 +596,5 @@ export function createDamage({ THREE, scene, meshes, MOBILE, ground, uDmgT, uCru
   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, heapPts];
-  return { objects, shared, blankTex, bruise, crush, tear, wetAt, ignite, debris, drops, update, reset, stats, crumble, 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) };
+  return { objects, shared, blankTex, bruise, crush, tear, wetAt, ignite, debris, drops, update, reset, stats, crumble, 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, 10, 0.05, 0.043, 0.038, 0.8) };
 }

docs/REALISM.md

@@ -0,0 +1,23 @@
+# How Destroy mode behaves, and why
+
+The scroll is carbonized papyrus. The eruption heated the rolls to combustion temperature with no oxygen around them, so they became something close to charcoal: black, light, brittle and layered. Sheets that were pressed together during manufacture and burial are fused in places, and in other places they have bubbled or come apart. The tools are tuned to that material and not to paper. This is for fun, not a simulation of conservation practice.
+
+## What the sources say
+
+- Carbonization left the rolls "similar to pieces of burnt wood, very fragile and extremely difficult to unroll without losing large portions of the scroll" (*A computational platform for the virtual unfolding of Herculaneum Papyri*, Scientific Reports, <https://www.nature.com/articles/s41598-020-80458-z>).
+- The rolls are "blackened and brittle like charcoal ... easily falling to pieces with light contact". Carbonization "often causes these sheets to bubble or delaminate" (Parsons et al., EduceLab-Scrolls, 2023, <https://arxiv.org/abs/2304.02084>).
+- Physical opening, whether by Piaggio's machine, by cutting the hard outer *scorza*, or by the 1980s Oslo method, broke the rolls into fragments and lost text (Mocella et al., *Nature Communications* 2015, <https://www.nature.com/articles/ncomms6895>; *Analysis of Herculaneum Papyri with X-Ray Computed Tomography*, micro-CT of P.Herc.Paris 3 and 4, <https://www.ndt.net/article/art2011/papers/FIELD%20-%20M%2014.pdf>).
+- Liquids did damage. Over the centuries the rolls were immersed in water, and some were painted with mercury, which turned them to mush (the micro-CT paper above; BYU Magazine, "A Library of Mud and Ashes", <https://magazine.byu.edu/article/a-library-of-mud-and-ashes/>). Humidity speeds the decay of charred papyrus (*Digitization and Digital Preservation of P.Herc. 817*, BYU thesis, <https://scholarsarchive.byu.edu/cgi/viewcontent.cgi?article=11264&context=etd>).
+- Charcoal smoulders rather than flames. It glows dull orange at the burning front, shrinks and cracks, and leaves light grey ash with little smoke. That is general combustion behaviour of char, used here as a qualitative guide.
+
+## What each tool does
+
+| Tool | Behaviour |
+| --- | --- |
+| Tear | No stretching or peeling. A grab snaps and crumbles the sheet at the grab point into small flakes and black dust, and a crack runs off along the fibres of that layer. Fractures follow the fibre direction and existing cracks. Fused layers let go easily (lower glue strength). |
+| Crush | Powders into fine black dust and a few small flakes with very little springback. |
+| Burn | Smoulders: a dim, slowly breathing deep orange glow in the charred band creeps slowly along the fibres. Edges char and break away, flakes drop, faint smoke rises, and the ash is light grey. Sparks are rare and dull. |
+| Water | Darkens to a matt black-brown with no gloss. The sheet swells slightly and slumps a little, with no paper-like sag. Layers lift apart, and soaked spots dissolve into black sludge that drips and drops sodden fragments onto a dark puddle. |
+| Crumble | The whole scroll breaks up from its edges inward over about four seconds and collapses into a heap of black dust and flakes. |
+
+Dust is dark charcoal and very light. It settles at about 2.5 mm/s and drifts on air currents. The only light source is the smouldering embers.

index.html

@@ -26,9 +26,9 @@
 <link rel="preconnect" href="https://fonts.googleapis.com">
 <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
 <link href="https://fonts.googleapis.com/css2?family=Instrument+Serif:ital@0;1&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
-<link rel="stylesheet" href="style.css?v=20261016f">
-<link rel="stylesheet" href="bench.css?v=20261016f">
-<link rel="stylesheet" href="ui.css?v=20261016f">
+<link rel="stylesheet" href="style.css?v=20261016g">
+<link rel="stylesheet" href="bench.css?v=20261016g">
+<link rel="stylesheet" href="ui.css?v=20261016g">
 <!-- start the big downloads and the 3D library in parallel with the page instead of one after another -->
 <link rel="modulepreload" href="https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js" crossorigin>
 <script>
@@ -202,9 +202,9 @@ if (!/(^|[#&])s=/.test(location.hash)) ['scrolls/index.json', 'scrolls/PHerc0139
   </div>
 </section>
 
-<script type="module" src="app.js?v=20261016f"></script>
-<script type="module" src="polish.js?v=20261016f"></script>
-<script type="module" src="lib/bench.js?v=20261016f"></script>
-<script type="module" src="ui.js?v=20261016f"></script>
+<script type="module" src="app.js?v=20261016g"></script>
+<script type="module" src="polish.js?v=20261016g"></script>
+<script type="module" src="lib/bench.js?v=20261016g"></script>
+<script type="module" src="ui.js?v=20261016g"></script>
 </body>
 </html>

tear.js

@@ -1,4 +1,4 @@
-import { DMG_HEAD as DMG_HEAD_T, DMG_CUT as DMG_CUT_T, DMG_EDGE as DMG_EDGE_T } from './damage.js?v=20261016b';
+import { DMG_HEAD as DMG_HEAD_T, DMG_CUT as DMG_CUT_T, DMG_EDGE as DMG_EDGE_T } from './damage.js?v=20261016g';
 // "Tear apart": a just-for-fun brittle fracture toy on top of the unrolled strip.
 // Not a real unrolling. Position based dynamics (Verlet + distance constraints) on typed arrays,
 // with real cracks: a crack is a jagged polyline in the sheet's own material space that grows from
@@ -26,20 +26,20 @@ const P = {
   layerGap: 0.22,     // mm between recto and verso
   thickness: 0.15,    // mm, dark torn edge face
   gravity: 9810,      // mm/s^2
-  drag: 1.6,          // 1/s velocity loss for sheet nodes (low density)
+  drag: 2.4,          // 1/s velocity loss for sheet nodes (low density)
   substeps: 1,
   iters: 6,
   strainAlong: 0.009, // failure strain along the fibres of a layer (crack runs along fibres)
   strainAcross: 0.018,
   jitter: 0.45,       // +/- fraction of random scatter in thresholds
   bendCrackDeg: 14,   // fold angle at a node that cracks it
-  glueGap: 0.55,      // mm of layer separation that delaminates recto from verso
+  glueGap: 0.35,      // mm of layer separation that delaminates recto from verso
   fuseStrain: 0.012,  // adhesion between neighbouring windings
   peelFrac: 0.85,     // a stuck node lets go of the backing above this fraction of its failure strain
-  peelProb: 0.25,
+  peelProb: 0.08,   // brittle: it snaps rather than peels
   shatterSpeed: 700,  // mm/s impact speed that shatters links at a node
   tipGrow: 0.8,       // a crack tip advances while nearby links are above this fraction of failure
-  fibreBias: 0.62,    // how strongly cracks follow the fibres of their layer
+  fibreBias: 0.75,    // how strongly cracks follow the fibres of their layer
   turnJitter: 0.38,   // radians of random wander per step
   branch: 0.025,      // chance per step that a crack forks
   stepsPerTip: 4,     // propagation steps per tip per frame, at most
@@ -1251,14 +1251,14 @@ ${DMG_EDGE_T}
     dv[k * 3] = (Math.random() - 0.5) * 30; dv[k * 3 + 1] = 8 + Math.random() * 20; dv[k * 3 + 2] = 10 + Math.random() * 25;
     dl[k] = 1;
   }
-  function crushAt(lay, k0, point) {
+  function crushAt(lay, k0, point, rScale = 1) {
     const s = lay.s;
     if (!s.cracked) { s.cracked = true; for (const l of s.lay) makeFine(l); }
     const F = lay.F;
     const mx = matX[k0] + (Math.random() - 0.5) * s.cw * 0.6, my = matY[k0] + (Math.random() - 0.5) * s.ch * 0.6;
     // map the actual hit point into material space using the nearest node's displacement
     const hx = mx + (point.x - pos[k0 * 3]) * 0.9, hy = my - (point.y - pos[k0 * 3 + 1]) * 0.9;
-    const R0 = 2.0 + Math.random() * 1.6;
+    const R0 = (2.0 + Math.random() * 1.6) * rScale;
     const ph1 = Math.random() * 6.3, ph2 = Math.random() * 6.3;
     const rAt = (a) => R0 * (0.78 + 0.16 * Math.sin(3 * a + ph1) + 0.1 * Math.sin(7 * a + ph2) + 0.06 * Math.random());
     // the visible hole is drawn by the damage mask in UV space: a smooth, fibrous edge with no triangle staircase.
@@ -1285,14 +1285,15 @@ ${DMG_EDGE_T}
     const w = worldAt(lay, hx, hy);
     let made = 0;
     while (left > 0 && made < 40) {
-      const sz = Math.random() < 0.3 ? 0.9 + Math.random() * 1.4 : 0.25 + Math.random() * 0.6;
+      const sz = (Math.random() < 0.12 ? 0.8 + Math.random() * 1.0 : 0.2 + Math.random() * 0.45) * rScale;
       left -= sz * sz * 0.6;
       const a = Math.random() * 6.3, r = Math.random() * R0;
       addCrumb(w[0] + Math.cos(a) * r, w[1] + Math.sin(a) * r, w[2] + 0.3 + Math.random() * 0.4,
-        Math.cos(a) * (30 + Math.random() * 80), Math.random() * 60, 40 + Math.random() * 90, sz);
+        // charcoal powders under a press: pieces barely spring back, they slump out and fall
+        Math.cos(a) * (8 + Math.random() * 22), Math.random() * 12, 6 + Math.random() * 20, sz);
       made++;
     }
-    for (let q = 0; q < 3; q++) spawnDust(w[0] + (Math.random() - 0.5) * R0, w[1] + (Math.random() - 0.5) * R0, w[2]);
+    for (let q = 0; q < 8; q++) spawnDust(w[0] + (Math.random() - 0.5) * R0, w[1] + (Math.random() - 0.5) * R0, w[2]);   // mostly black dust
     active[sheetOf[k0]] = 1; calm[sheetOf[k0]] = 0; s.islandDirty = true;
     crunch();
     breaks++;
@@ -1336,6 +1337,18 @@ ${DMG_EDGE_T}
       e.stopImmediatePropagation();
       return;
     }
+    // carbonized papyrus does not stretch or peel under fingers: it snaps and crumbles where it is grabbed
+    crushAt(lay, best, hit.point, 0.55);
+    for (let q = 0; q < 2; q++) {   // and a snap runs off along the fibres of this layer
+      const along = L === 0 ? [1, 0] : [0, 1], sg = q ? -1 : 1;
+      seedCrack(lay, matX[best] + along[0] * sg * 1.2, matY[best] + along[1] * sg * 1.2, along[0] * sg, along[1] * sg);
+    }
+    if (!valid[best]) {   // the grab point itself went to dust: hold the nearest piece that is left
+      let nb = -1, nd = Infinity;
+      for (let k = lay.base; k < lay.base + s.R * s.C; k++) { if (!valid[k]) continue; const d = (matX[k] - matX[best]) ** 2 + (matY[k] - matY[best]) ** 2; if (d < nd) { nd = d; nb = k; } }
+      if (nb < 0) return;
+      best = nb;
+    }
     grabbed = best;
     active[sheetOf[best]] = 1; calm[sheetOf[best]] = 0;
     // pinch everything within about 1.6 nodes of the hit, on the layer that was touched