@adatechnology/game-destruction-three 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,2551 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/math.ts
+function createRng(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function hashNumbers(...values) {
+  let h = 2166136261;
+  for (const v of values) {
+    const n = Math.round(v * 1e3) | 0;
+    h = Math.imul(h ^ n, 16777619);
+    h ^= h >>> 13;
+  }
+  return h >>> 0;
+}
+function hashString(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) h = Math.imul(h ^ s.charCodeAt(i), 16777619);
+  return h >>> 0;
+}
+var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+var lerp = (a, b, t) => a + (b - a) * t;
+function hexToRgb(hex) {
+  return [(hex >> 16 & 255) / 255, (hex >> 8 & 255) / 255, (hex & 255) / 255];
+}
+function mixHex(a, b, t) {
+  const ar = a >> 16 & 255;
+  const ag = a >> 8 & 255;
+  const ab = a & 255;
+  const r = Math.round(ar + ((b >> 16 & 255) - ar) * t);
+  const g = Math.round(ag + ((b >> 8 & 255) - ag) * t);
+  const bl = Math.round(ab + ((b & 255) - ab) * t);
+  return r << 16 | g << 8 | bl;
+}
+
+// src/fragments.ts
+var FragmentSystem = class {
+  constructor(THREE, o) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "o", o);
+    __publicField(this, "list", []);
+    __publicField(this, "box");
+    __publicField(this, "shardGeos", []);
+    __publicField(this, "materials", /* @__PURE__ */ new Map());
+    __publicField(this, "q");
+    __publicField(this, "dq");
+    __publicField(this, "m");
+    __publicField(this, "v");
+    __publicField(this, "w");
+    __publicField(this, "rng", createRng(1374496523));
+    this.box = new THREE.BoxGeometry(1, 1, 1);
+    this.q = new THREE.Quaternion();
+    this.dq = new THREE.Quaternion();
+    this.m = new THREE.Matrix4();
+    this.v = new THREE.Vector3();
+    this.w = new THREE.Vector3();
+  }
+  get count() {
+    return this.list.length;
+  }
+  /** Meshes of every live fragment (tests and picking). */
+  meshes() {
+    return this.list.map((f) => f.mesh);
+  }
+  /** One shared material per source material id + colour (+ transparency). */
+  materialFor(materialId, color, transparent, opacity = 0.5) {
+    const key = `${materialId}:${color}:${transparent ? 1 : 0}`;
+    let m = this.materials.get(key);
+    if (!m) {
+      m = transparent ? new this.THREE.MeshStandardMaterial({ color, roughness: 0.15, metalness: 0.1, transparent: true, opacity, side: this.THREE.DoubleSide, depthWrite: false }) : new this.THREE.MeshLambertMaterial({ color });
+      this.materials.set(key, m);
+    }
+    return m;
+  }
+  shardGeometry(seed) {
+    const idx = seed % 6;
+    let g = this.shardGeos[idx];
+    if (!g) {
+      const r = createRng(1e3 + idx);
+      const n = 3 + Math.floor(r() * 3);
+      const shape = new this.THREE.Shape();
+      const pts = [];
+      for (let i = 0; i < n; i++) {
+        const a = i / n * Math.PI * 2 + (r() - 0.5) * 0.7;
+        const rad = 0.35 + r() * 0.15;
+        pts.push([Math.cos(a) * rad, Math.sin(a) * rad]);
+      }
+      shape.moveTo(pts[0][0], pts[0][1]);
+      for (let i = 1; i < n; i++) shape.lineTo(pts[i][0], pts[i][1]);
+      shape.closePath();
+      g = new this.THREE.ExtrudeGeometry(shape, { depth: 1, bevelEnabled: false });
+      g.translate(0, 0, -0.5);
+      this.shardGeos[idx] = g;
+    }
+    return g;
+  }
+  /** Create the mesh of a fragment and start its motion. `maxAllowed` is the live budget. */
+  spawn(f, material, home, maxAllowed) {
+    const geo = f.shape === "shard" ? this.shardGeometry(hashString(f.id)) : this.box;
+    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();
+    const sz = f.size;
+    const sc = new this.THREE.Vector3(Math.max(5e-3, sz[0]), Math.max(5e-3, sz[1]), Math.max(3e-3, sz[2]));
+    mesh.scale.copy(sc);
+    mesh.castShadow = true;
+    this.o.scene.add(mesh);
+    const live = {
+      mesh,
+      home,
+      vel: new this.THREE.Vector3(f.velocity[0], f.velocity[1], f.velocity[2]),
+      ang: new this.THREE.Vector3(f.angularVelocity[0], f.angularVelocity[1], f.angularVelocity[2]),
+      // shards are thin: the contact extent uses the real (small) thickness, the chunk uses half of each side
+      half: sc.clone().multiplyScalar(0.5),
+      baseScale: sc,
+      still: 0,
+      asleep: false,
+      rest: 0,
+      fade: 1,
+      dying: false
+    };
+    this.list.push(live);
+    let alive = this.list.reduce((n, l) => n + (l.dying ? 0 : 1), 0);
+    for (let i = 0; i < this.list.length && alive > maxAllowed; i++) {
+      if (!this.list[i].dying) {
+        this.list[i].dying = true;
+        alive--;
+      }
+    }
+  }
+  /** Add velocity to every fragment within `radius` of a point (blasts). */
+  blast(point, radius, speed) {
+    for (const f of this.list) {
+      const d = this.v.copy(f.mesh.position).sub(this.w.set(point[0], point[1], point[2]));
+      const dist = d.length();
+      if (dist > radius || f.dying) continue;
+      const k = (1 - dist / radius) ** 2 * speed;
+      d.normalize().multiplyScalar(k);
+      d.y += k * 0.4;
+      f.vel.add(d);
+      f.ang.add(this.w.set(this.rng() - 0.5, this.rng() - 0.5, this.rng() - 0.5).multiplyScalar(k));
+      f.asleep = false;
+      f.rest = 0;
+    }
+  }
+  update(dt) {
+    const g = this.o.gravity;
+    for (let i = this.list.length - 1; i >= 0; i--) {
+      const f = this.list[i];
+      if (f.dying) {
+        f.fade -= dt / 0.6;
+        if (f.fade <= 0) {
+          this.o.scene.remove(f.mesh);
+          this.list.splice(i, 1);
+          continue;
+        }
+        f.mesh.scale.copy(f.baseScale).multiplyScalar(f.fade);
+      }
+      if (f.asleep) {
+        f.rest += dt;
+        if (this.o.life > 0 && f.rest > this.o.life) f.dying = true;
+        continue;
+      }
+      this.step(f, dt, g);
+    }
+  }
+  step(f, dt, g) {
+    const mesh = f.mesh;
+    f.vel.y -= g * dt;
+    mesh.position.addScaledVector(f.vel, dt);
+    const w = f.ang.length();
+    if (w > 1e-5) {
+      this.dq.setFromAxisAngle(this.v.copy(f.ang).multiplyScalar(1 / w), w * dt);
+      mesh.quaternion.premultiply(this.dq).normalize();
+    }
+    this.m.makeRotationFromQuaternion(mesh.quaternion);
+    const e = this.m.elements;
+    const h = f.half;
+    const sc = f.dying ? f.fade : 1;
+    const ext = (Math.abs(e[1]) * h.x + Math.abs(e[5]) * h.y + Math.abs(e[9]) * h.z) * sc;
+    const gy = this.o.groundAt(mesh.position.x, mesh.position.z);
+    let contact = false;
+    if (mesh.position.y - ext < gy) {
+      contact = true;
+      mesh.position.y = gy + ext;
+      if (f.vel.y < -0.6) {
+        f.vel.y = -f.vel.y * 0.25;
+        f.vel.x *= 0.7;
+        f.vel.z *= 0.7;
+        f.ang.multiplyScalar(0.55);
+        f.ang.x += (this.rng() - 0.5) * 2;
+        f.ang.z += (this.rng() - 0.5) * 2;
+      } else {
+        f.vel.y = 0;
+        const fr = Math.exp(-7 * dt);
+        f.vel.x *= fr;
+        f.vel.z *= fr;
+        f.ang.multiplyScalar(Math.exp(-6 * dt));
+      }
+    } else {
+      f.ang.multiplyScalar(Math.exp(-0.15 * dt));
+    }
+    if (contact && f.vel.lengthSq() < 4) this.settle(f, dt);
+    const slow = f.vel.lengthSq() < 0.012 && f.ang.lengthSq() < 0.2;
+    if (contact && slow) {
+      f.still += dt;
+      if (f.still > 0.4) {
+        f.asleep = true;
+        f.vel.set(0, 0, 0);
+        f.ang.set(0, 0, 0);
+      }
+    } else {
+      f.still = 0;
+    }
+  }
+  /** Tip the fragment towards lying on its flattest face. */
+  settle(f, dt) {
+    const mesh = f.mesh;
+    this.m.makeRotationFromQuaternion(mesh.quaternion);
+    const e = this.m.elements;
+    const up = [e[1], e[5], e[9]];
+    const half = [f.half.x, f.half.y, f.half.z];
+    let small = 0;
+    for (let i = 1; i < 3; i++) if (half[i] < half[small]) small = i;
+    let axis = small;
+    if (Math.abs(up[small]) < 0.35) {
+      axis = 0;
+      for (let i = 1; i < 3; i++) if (Math.abs(up[i]) > Math.abs(up[axis])) axis = i;
+    }
+    const sign = up[axis] >= 0 ? 1 : -1;
+    this.v.set(e[axis * 4], e[axis * 4 + 1], e[axis * 4 + 2]).multiplyScalar(sign);
+    this.w.set(0, 1, 0);
+    this.dq.setFromUnitVectors(this.v, this.w);
+    this.q.copy(this.dq).multiply(mesh.quaternion);
+    mesh.quaternion.slerp(this.q, clamp(dt * 7, 0, 1));
+  }
+  /** Remove the fragments of one object (after `restore`). */
+  removeHome(home) {
+    for (let i = this.list.length - 1; i >= 0; i--) {
+      if (this.list[i].home === home) {
+        this.o.scene.remove(this.list[i].mesh);
+        this.list.splice(i, 1);
+      }
+    }
+  }
+  clear() {
+    for (const f of this.list) this.o.scene.remove(f.mesh);
+    this.list.length = 0;
+  }
+  dispose() {
+    this.clear();
+    this.box.dispose();
+    for (const g of this.shardGeos) g?.dispose();
+    this.shardGeos = [];
+    for (const m of this.materials.values()) m.dispose();
+    this.materials.clear();
+  }
+};
+
+// src/ground.ts
+var MAX_RADIUS = 1.2;
+var GroundSpots = class {
+  constructor(THREE, scene, groundAt, cap) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "scene", scene);
+    __publicField(this, "groundAt", groundAt);
+    __publicField(this, "cap", cap);
+    __publicField(this, "spots", []);
+    __publicField(this, "geometry");
+    __publicField(this, "materials", /* @__PURE__ */ new Map());
+    this.geometry = new THREE.CircleGeometry(1, 20);
+    this.geometry.rotateX(-Math.PI / 2);
+  }
+  get count() {
+    return this.spots.length;
+  }
+  material(kind, color) {
+    const key = `${kind}:${color}`;
+    let m = this.materials.get(key);
+    if (!m) {
+      m = new this.THREE.MeshBasicMaterial({
+        color,
+        transparent: true,
+        opacity: kind === "puddle" ? 0.88 : 0.95,
+        depthWrite: false,
+        polygonOffset: true,
+        polygonOffsetFactor: -2,
+        polygonOffsetUnits: -2
+      });
+      this.materials.set(key, m);
+    }
+    return m;
+  }
+  /** Add (or grow) a spot at (x, z). `radius` is the radius this addition contributes. */
+  add(kind, x, z, radius, color, home) {
+    for (const s of this.spots) {
+      if (s.kind !== kind) continue;
+      const d = Math.hypot(s.x - x, s.z - z);
+      if (d < Math.max(s.target, radius) * 0.9) {
+        s.target = Math.min(MAX_RADIUS, Math.sqrt(s.target * s.target + radius * radius * 0.5));
+        return;
+      }
+    }
+    while (this.spots.length >= this.cap) this.remove(this.spots[0]);
+    const mesh = new this.THREE.Mesh(this.geometry, this.material(kind, color));
+    const y = this.groundAt(x, z) + 4e-3 + this.spots.length % 8 * 4e-4;
+    mesh.position.set(x, y, z);
+    mesh.scale.setScalar(1e-3);
+    mesh.renderOrder = 1;
+    this.scene.add(mesh);
+    this.spots.push({ mesh, kind, home, x, z, radius: 1e-3, target: Math.min(MAX_RADIUS, radius) });
+  }
+  remove(s) {
+    const i = this.spots.indexOf(s);
+    if (i >= 0) this.spots.splice(i, 1);
+    this.scene.remove(s.mesh);
+  }
+  update(dt) {
+    const k = Math.min(1, dt * 3);
+    for (const s of this.spots) {
+      if (Math.abs(s.radius - s.target) < 1e-4) continue;
+      s.radius = lerp(s.radius, s.target, k);
+      s.mesh.scale.setScalar(s.radius);
+    }
+  }
+  /** Remove the spots made for one object (after its `restore`). */
+  removeHome(home) {
+    for (const s of [...this.spots]) if (s.home === home) this.remove(s);
+  }
+  clear() {
+    for (const s of [...this.spots]) this.remove(s);
+  }
+  dispose() {
+    this.clear();
+    this.geometry.dispose();
+    for (const m of this.materials.values()) m.dispose();
+    this.materials.clear();
+  }
+};
+
+// src/particles.ts
+var KINDS = {
+  fire: { additive: true, life: [0.45, 0.9], size: [0.1, 0.2], grow: 0.3, gravity: 0, rise: 2.4, drag: 1.2, c0: 16760896, c1: 12591104, alpha: 0.9, fadeIn: 0.12, cone: 0.7, ground: "none", flicker: 0.35 },
+  smoke: { additive: false, life: [1.8, 3.2], size: [0.14, 0.24], grow: 3.2, gravity: 0, rise: 0.7, drag: 0.8, c0: 6710886, c1: 10132122, alpha: 0.35, fadeIn: 0.15, cone: 0.6, ground: "none" },
+  sparks: { additive: true, life: [0.25, 0.6], size: [0.018, 0.03], grow: 0.5, gravity: 1, rise: 0, drag: 0.3, c0: 16773792, c1: 16738832, alpha: 1, fadeIn: 0.02, cone: 0.55, ground: "bounce" },
+  dust: { additive: false, life: [1, 2], size: [0.08, 0.14], grow: 2.5, gravity: 0.05, rise: 0, drag: 2.5, c0: 9274745, c1: 9274745, alpha: 0.4, fadeIn: 0.1, cone: 0.4, ground: "none" },
+  shards: { additive: true, life: [0.8, 1.4], size: [0.02, 0.035], grow: 0.8, gravity: 1, rise: 0, drag: 0.2, c0: 14677247, c1: 10473727, alpha: 0.9, fadeIn: 0.03, cone: 0.5, ground: "bounce", flicker: 0.5 },
+  splinters: { additive: false, life: [0.8, 1.5], size: [0.02, 0.035], grow: 1, gravity: 1, rise: 0, drag: 0.3, c0: 10516042, c1: 8017200, alpha: 1, fadeIn: 0.02, cone: 0.5, ground: "bounce" },
+  chips: { additive: false, life: [0.8, 1.5], size: [0.025, 0.04], grow: 1, gravity: 1, rise: 0, drag: 0.3, c0: 9077624, c1: 7235679, alpha: 1, fadeIn: 0.02, cone: 0.5, ground: "bounce" },
+  fibers: { additive: false, life: [1.5, 2.5], size: [0.02, 0.03], grow: 1, gravity: 0.15, rise: 0, drag: 2, c0: 12101768, c1: 12101768, alpha: 0.9, fadeIn: 0.05, cone: 0.4, ground: "stop", flutter: 2.5 },
+  leaves: { additive: false, life: [1.5, 2.8], size: [0.03, 0.05], grow: 1, gravity: 0.15, rise: 0, drag: 2, c0: 6003260, c1: 4882224, alpha: 0.95, fadeIn: 0.05, cone: 0.4, ground: "stop", flutter: 2.8 },
+  drips: { additive: false, life: [2, 3], size: [0.025, 0.035], grow: 1, gravity: 1, rise: 0, drag: 0, c0: 6974058, c1: 6974058, alpha: 1, fadeIn: 0.01, cone: 0.2, ground: "land" },
+  ash: { additive: false, life: [2, 4], size: [0.02, 0.04], grow: 1.2, gravity: 0.08, rise: 0, drag: 1.5, c0: 2762275, c1: 1710102, alpha: 0.8, fadeIn: 0.1, cone: 0.5, ground: "stop", flutter: 0.6 },
+  steam: { additive: false, life: [1, 2], size: [0.12, 0.2], grow: 3, gravity: 0, rise: 0.9, drag: 1, c0: 16777215, c1: 14739694, alpha: 0.35, fadeIn: 0.15, cone: 0.6, ground: "none" },
+  flash: { additive: true, life: [0.12, 0.2], size: [1.2, 1.8], grow: 1.6, gravity: 0, rise: 0, drag: 0, c0: 16774080, c1: 16748592, alpha: 1, fadeIn: 0.1, cone: 0, ground: "none" },
+  foam: { additive: false, life: [1, 1.8], size: [0.06, 0.1], grow: 1.5, gravity: 0.6, rise: 0, drag: 1.5, c0: 16054527, c1: 14542576, alpha: 0.8, fadeIn: 0.05, cone: 0.5, ground: "stop" }
+};
+var KIND_IDS = Object.keys(KINDS);
+var KIND_INDEX = {};
+KIND_IDS.forEach((k, i) => KIND_INDEX[k] = i);
+var KIND_LIST = KIND_IDS.map((k) => KINDS[k]);
+var VERT = `
+uniform float uScale;
+attribute float size;
+attribute float alpha;
+attribute vec3 pcolor;
+varying float vAlpha;
+varying vec3 vColor;
+void main() {
+  vAlpha = alpha;
+  vColor = pcolor;
+  vec4 mv = modelViewMatrix * vec4(position, 1.0);
+  gl_PointSize = min(size * uScale / max(0.1, -mv.z), 256.0);
+  gl_Position = projectionMatrix * mv;
+}`;
+var FRAG = `
+varying float vAlpha;
+varying vec3 vColor;
+void main() {
+  float d = length(gl_PointCoord - vec2(0.5)) * 2.0;
+  float a = (1.0 - smoothstep(0.35, 1.0, d)) * vAlpha;
+  if (a < 0.004) discard;
+  gl_FragColor = vec4(vColor, a);
+}`;
+var Pool = class {
+  constructor(THREE, capacity, additive, pointScale) {
+    __publicField(this, "capacity", capacity);
+    __publicField(this, "points");
+    __publicField(this, "geometry");
+    __publicField(this, "material");
+    __publicField(this, "live", 0);
+    __publicField(this, "next", 0);
+    __publicField(this, "high", 0);
+    __publicField(this, "pos");
+    __publicField(this, "col");
+    __publicField(this, "alp");
+    __publicField(this, "siz");
+    __publicField(this, "vel");
+    __publicField(this, "age");
+    __publicField(this, "life");
+    __publicField(this, "size0");
+    __publicField(this, "alive");
+    __publicField(this, "kind");
+    __publicField(this, "seed");
+    __publicField(this, "alphaMul");
+    __publicField(this, "tag");
+    __publicField(this, "colorHex");
+    __publicField(this, "bounced");
+    const n = Math.max(1, capacity);
+    this.pos = new Float32Array(n * 3);
+    this.col = new Float32Array(n * 3);
+    this.alp = new Float32Array(n);
+    this.siz = new Float32Array(n);
+    this.vel = new Float32Array(n * 3);
+    this.age = new Float32Array(n);
+    this.life = new Float32Array(n);
+    this.size0 = new Float32Array(n);
+    this.alive = new Uint8Array(n);
+    this.kind = new Uint8Array(n);
+    this.seed = new Float32Array(n);
+    this.alphaMul = new Float32Array(n);
+    this.tag = new Int32Array(n);
+    this.colorHex = new Int32Array(n);
+    this.bounced = new Uint8Array(n);
+    this.geometry = new THREE.BufferGeometry();
+    const attr = (a, size) => {
+      const at = new THREE.BufferAttribute(a, size);
+      at.setUsage(THREE.DynamicDrawUsage);
+      return at;
+    };
+    this.geometry.setAttribute("position", attr(this.pos, 3));
+    this.geometry.setAttribute("pcolor", attr(this.col, 3));
+    this.geometry.setAttribute("alpha", attr(this.alp, 1));
+    this.geometry.setAttribute("size", attr(this.siz, 1));
+    this.geometry.setDrawRange(0, 0);
+    this.material = new THREE.ShaderMaterial({
+      uniforms: { uScale: { value: pointScale } },
+      vertexShader: VERT,
+      fragmentShader: FRAG,
+      transparent: true,
+      depthWrite: false,
+      blending: additive ? THREE.AdditiveBlending : THREE.NormalBlending
+    });
+    this.points = new THREE.Points(this.geometry, this.material);
+    this.points.frustumCulled = false;
+    this.points.name = additive ? "destruction-particles-additive" : "destruction-particles";
+    this.points.renderOrder = additive ? 11 : 10;
+  }
+  spawn(kind, x, y, z, vx, vy, vz, def, rnd, o) {
+    if (this.capacity <= 0) return;
+    const i = this.next;
+    this.next = (this.next + 1) % this.capacity;
+    if (this.alive[i]) this.live--;
+    this.alive[i] = 1;
+    this.live++;
+    if (i + 1 > this.high) this.high = i + 1;
+    this.kind[i] = kind;
+    this.pos[i * 3] = x;
+    this.pos[i * 3 + 1] = y;
+    this.pos[i * 3 + 2] = z;
+    this.vel[i * 3] = vx;
+    this.vel[i * 3 + 1] = vy;
+    this.vel[i * 3 + 2] = vz;
+    this.age[i] = 0;
+    this.life[i] = lerp(def.life[0], def.life[1], rnd()) * (o?.life ?? 1);
+    this.size0[i] = lerp(def.size[0], def.size[1], rnd()) * (o?.size ?? 1);
+    this.seed[i] = rnd();
+    this.alphaMul[i] = o?.alpha ?? 1;
+    this.tag[i] = o?.tag ?? 0;
+    this.colorHex[i] = o?.color ?? -1;
+    this.bounced[i] = 0;
+    this.siz[i] = this.size0[i];
+    this.alp[i] = 0;
+  }
+  kill(i) {
+    if (!this.alive[i]) return;
+    this.alive[i] = 0;
+    this.live--;
+    this.alp[i] = 0;
+    this.siz[i] = 0;
+  }
+  clear() {
+    this.alive.fill(0);
+    this.alp.fill(0);
+    this.siz.fill(0);
+    this.live = 0;
+    this.high = 0;
+    this.next = 0;
+    this.geometry.setDrawRange(0, 0);
+  }
+  /** Move a live particle (used by external pushes such as blasts). */
+  push(cx, cy, cz, radius, speed) {
+    for (let i = 0; i < this.high; i++) {
+      if (!this.alive[i]) continue;
+      const dx = this.pos[i * 3] - cx;
+      const dy = this.pos[i * 3 + 1] - cy;
+      const dz = this.pos[i * 3 + 2] - cz;
+      const d = Math.hypot(dx, dy, dz);
+      if (d > radius || d < 1e-4) continue;
+      const f = (1 - d / radius) * speed;
+      this.vel[i * 3] += dx / d * f;
+      this.vel[i * 3 + 1] += dy / d * f;
+      this.vel[i * 3 + 2] += dz / d * f;
+    }
+  }
+  update(dt, host) {
+    let top = 0;
+    for (let i = 0; i < this.high; i++) {
+      if (!this.alive[i]) continue;
+      const def = KIND_LIST[this.kind[i]];
+      const age = this.age[i] += dt;
+      const life = this.life[i];
+      if (age >= life) {
+        this.kill(i);
+        continue;
+      }
+      const t = age / life;
+      const i3 = i * 3;
+      let vx = this.vel[i3];
+      let vy = this.vel[i3 + 1];
+      let vz = this.vel[i3 + 2];
+      vy += (def.rise - def.gravity * host.gravity) * dt;
+      if (def.flutter) {
+        const ph = age * 7 + this.seed[i] * 40;
+        vx += Math.sin(ph) * def.flutter * dt;
+        vz += Math.cos(ph * 1.3) * def.flutter * dt;
+      }
+      if (def.drag > 0) {
+        const k = Math.exp(-def.drag * dt);
+        vx *= k;
+        vy *= k;
+        vz *= k;
+      }
+      const x = this.pos[i3] + vx * dt;
+      let y = this.pos[i3 + 1] + vy * dt;
+      const z = this.pos[i3 + 2] + vz * dt;
+      if (def.ground !== "none") {
+        const gy = host.groundAt(x, z) + 5e-3;
+        if (y < gy) {
+          if (def.ground === "land") {
+            const tag = this.tag[i];
+            if (tag !== 0) host.onLand(x, gy, z, this.colorHex[i] >= 0 ? this.colorHex[i] : def.c0, tag);
+            this.kill(i);
+            continue;
+          }
+          y = gy;
+          if (def.ground === "bounce" && !this.bounced[i]) {
+            this.bounced[i] = 1;
+            vy = Math.abs(vy) * 0.35;
+            vx *= 0.6;
+            vz *= 0.6;
+          } else {
+            vx = vy = vz = 0;
+          }
+        }
+      }
+      this.vel[i3] = vx;
+      this.vel[i3 + 1] = vy;
+      this.vel[i3 + 2] = vz;
+      this.pos[i3] = x;
+      this.pos[i3 + 1] = y;
+      this.pos[i3 + 2] = z;
+      this.siz[i] = this.size0[i] * lerp(1, def.grow, t);
+      const c0 = this.colorHex[i] >= 0 ? this.colorHex[i] : def.c0;
+      const c1 = this.colorHex[i] >= 0 ? this.colorHex[i] : def.c1;
+      const a = hexToRgb(c0);
+      const b = hexToRgb(c1);
+      this.col[i3] = lerp(a[0], b[0], t);
+      this.col[i3 + 1] = lerp(a[1], b[1], t);
+      this.col[i3 + 2] = lerp(a[2], b[2], t);
+      let env = t < def.fadeIn ? t / def.fadeIn : 1 - (t - def.fadeIn) / (1 - def.fadeIn);
+      if (def.flicker) env *= 1 - def.flicker * (0.5 + 0.5 * Math.sin(age * 38 + this.seed[i] * 50));
+      this.alp[i] = clamp(env, 0, 1) * def.alpha * this.alphaMul[i];
+      top = i + 1;
+    }
+    this.high = top;
+    this.geometry.setDrawRange(0, top);
+    for (const name of ["position", "pcolor", "alpha", "size"]) {
+      ;
+      this.geometry.getAttribute(name).needsUpdate = true;
+    }
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material.dispose();
+  }
+};
+var ParticleSystem = class {
+  constructor(THREE, o) {
+    __publicField(this, "o", o);
+    __publicField(this, "add");
+    __publicField(this, "normal");
+    __publicField(this, "rng", createRng(2654435761));
+    __publicField(this, "attached", false);
+    __publicField(this, "host");
+    const addCap = Math.floor(o.capacity * 0.4);
+    this.add = new Pool(THREE, addCap, true, o.pointScale);
+    this.normal = new Pool(THREE, o.capacity - addCap, false, o.pointScale);
+    this.host = { groundAt: o.groundAt, gravity: o.gravity, onLand: o.onLand };
+  }
+  get capacity() {
+    return this.add.capacity + this.normal.capacity;
+  }
+  get live() {
+    return this.add.live + this.normal.live;
+  }
+  ensureAttached() {
+    if (this.attached) return;
+    this.attached = true;
+    this.o.scene.add(this.add.points, this.normal.points);
+  }
+  /** Remove the Points from the scene (they come back on the next emit). */
+  detach() {
+    if (!this.attached) return;
+    this.attached = false;
+    this.o.scene.remove(this.add.points, this.normal.points);
+  }
+  /** Spawn one particle with an explicit velocity. */
+  spawn(kind, p, v, opts) {
+    const def = KINDS[kind];
+    this.ensureAttached();
+    (def.additive ? this.add : this.normal).spawn(KIND_INDEX[kind], p[0], p[1], p[2], v[0], v[1], v[2], def, this.rng, opts);
+  }
+  /** Spawn `count` particles leaving `point` around `normal` at about `speed` m/s. */
+  burst(kind, point, normal, count, speed = 1, opts) {
+    const def = KINDS[kind];
+    const n = Math.max(0, Math.round(count * this.o.density));
+    const rnd = this.rng;
+    const nl = Math.hypot(normal[0], normal[1], normal[2]) || 1;
+    const nx = normal[0] / nl;
+    const ny = normal[1] / nl;
+    const nz = normal[2] / nl;
+    for (let k = 0; k < n; k++) {
+      const u = rnd() * 2 - 1;
+      const ph = rnd() * Math.PI * 2;
+      const s = Math.sqrt(1 - u * u);
+      const rx = s * Math.cos(ph);
+      const ry = u;
+      const rz = s * Math.sin(ph);
+      let dx = nx * def.cone + rx * (1 - def.cone);
+      let dy = ny * def.cone + ry * (1 - def.cone);
+      let dz = nz * def.cone + rz * (1 - def.cone);
+      dx += rx * 0.35;
+      dy += ry * 0.35;
+      dz += rz * 0.35;
+      const l = Math.hypot(dx, dy, dz) || 1;
+      const sp = speed * (0.35 + 0.65 * rnd());
+      const jitter = 0.01 + (def.size[1] > 0.5 ? 0.15 : 0.02);
+      this.spawn(
+        kind,
+        [point[0] + (rnd() - 0.5) * jitter, point[1] + (rnd() - 0.5) * jitter, point[2] + (rnd() - 0.5) * jitter],
+        [dx / l * sp, dy / l * sp, dz / l * sp],
+        opts
+      );
+    }
+  }
+  /** Blast wave: shove live particles away from a point. */
+  push(point, radius, speed) {
+    this.add.push(point[0], point[1], point[2], radius, speed);
+    this.normal.push(point[0], point[1], point[2], radius, speed);
+  }
+  update(dt) {
+    if (this.add.live > 0 || this.add.points.geometry.drawRange.count > 0) this.add.update(dt, this.host);
+    if (this.normal.live > 0 || this.normal.points.geometry.drawRange.count > 0) this.normal.update(dt, this.host);
+  }
+  clear() {
+    this.add.clear();
+    this.normal.clear();
+    this.detach();
+  }
+  dispose() {
+    this.detach();
+    this.add.dispose();
+    this.normal.dispose();
+  }
+};
+
+// src/pieces.ts
+var SUB_DT = 1 / 120;
+var MU = 0.7;
+var SLEEP_AFTER = 0.5;
+var HARD_LANDING = 3;
+var SLOP = 2e-3;
+var NARROW = 0.3;
+var TOPPLE = 3;
+var PieceSystem = class {
+  constructor(THREE, o) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "o", o);
+    __publicField(this, "list", []);
+    __publicField(this, "time", 0);
+    __publicField(this, "p");
+    __publicField(this, "q");
+    __publicField(this, "dq");
+    __publicField(this, "m");
+    __publicField(this, "ax");
+    this.p = new THREE.Vector3();
+    this.q = new THREE.Quaternion();
+    this.dq = new THREE.Quaternion();
+    this.m = new THREE.Matrix4();
+    this.ax = new THREE.Vector3();
+  }
+  get(objectId) {
+    return this.list.find((b) => b.objectId === objectId) ?? null;
+  }
+  create(objectId, root, halfExtents, localCenter, mass, velocity, angular) {
+    const existing = this.get(objectId);
+    if (existing) {
+      existing.root = root;
+      existing.halfExtents = halfExtents;
+      existing.mass = mass;
+      this.setCenter(existing, localCenter);
+      if (velocity) existing.velocity = [...velocity];
+      existing.sleeping = false;
+      return existing;
+    }
+    const body = {
+      objectId,
+      root,
+      velocity: velocity ? [...velocity] : [0, 0, 0],
+      angularVelocity: angular ? [...angular] : [0, 0, 0],
+      halfExtents: [Math.max(0.01, halfExtents[0]), Math.max(0.01, halfExtents[1]), Math.max(0.01, halfExtents[2])],
+      mass: Math.max(0.05, mass),
+      sleeping: false,
+      held: false,
+      localCenter: [localCenter.x, localCenter.y, localCenter.z],
+      centerV: localCenter.clone(),
+      still: 0,
+      lastHit: -1,
+      onGround: false
+    };
+    this.list.push(body);
+    return body;
+  }
+  /** Move the centre of mass (after a part broke off). */
+  setCenter(b, c) {
+    b.centerV.copy(c);
+    b.localCenter = [c.x, c.y, c.z];
+  }
+  remove(objectId) {
+    const i = this.list.findIndex((b) => b.objectId === objectId);
+    if (i >= 0) this.list.splice(i, 1);
+  }
+  clear() {
+    this.list.length = 0;
+  }
+  /** World position of the centre of mass. */
+  centerOf(b, out) {
+    return out.copy(b.centerV).applyQuaternion(b.root.quaternion).add(b.root.position);
+  }
+  impulse(b, impulse, point) {
+    const inv = 1 / b.mass;
+    b.velocity[0] += impulse[0] * inv;
+    b.velocity[1] += impulse[1] * inv;
+    b.velocity[2] += impulse[2] * inv;
+    if (point) {
+      const c = this.centerOf(b, this.p);
+      const rx = point[0] - c.x;
+      const ry = point[1] - c.y;
+      const rz = point[2] - c.z;
+      const tx = ry * impulse[2] - rz * impulse[1];
+      const ty = rz * impulse[0] - rx * impulse[2];
+      const tz = rx * impulse[1] - ry * impulse[0];
+      const w = this.mulInvInertia(b, tx, ty, tz);
+      b.angularVelocity[0] += w[0];
+      b.angularVelocity[1] += w[1];
+      b.angularVelocity[2] += w[2];
+    }
+    b.sleeping = false;
+    b.still = 0;
+  }
+  /** I^-1 * (x, y, z) in world space for a box with the body's half extents and mass (needs `this.m` to hold the body's rotation). */
+  mulInvInertia(b, x, y, z) {
+    this.m.makeRotationFromQuaternion(b.root.quaternion);
+    return this.mulInvInertiaWith(b, this.m.elements, x, y, z);
+  }
+  mulInvInertiaWith(b, e, x, y, z) {
+    const [hx, hy, hz] = b.halfExtents;
+    const k = 3 / b.mass;
+    const ix = k / (hy * hy + hz * hz);
+    const iy = k / (hx * hx + hz * hz);
+    const iz = k / (hx * hx + hy * hy);
+    const lx = (e[0] * x + e[1] * y + e[2] * z) * ix;
+    const ly = (e[4] * x + e[5] * y + e[6] * z) * iy;
+    const lz = (e[8] * x + e[9] * y + e[10] * z) * iz;
+    return [e[0] * lx + e[4] * ly + e[8] * lz, e[1] * lx + e[5] * ly + e[9] * lz, e[2] * lx + e[6] * ly + e[10] * lz];
+  }
+  update(dt) {
+    this.time += dt;
+    for (const b of this.list) {
+      if (b.held) {
+        b.velocity = [0, 0, 0];
+        b.angularVelocity = [0, 0, 0];
+        b.sleeping = false;
+        b.still = 0;
+        continue;
+      }
+      if (b.sleeping) continue;
+      this.integrate(b, dt);
+    }
+    this.separate(dt);
+  }
+  integrate(b, dt) {
+    const c = this.centerOf(b, this.p);
+    const pos = [c.x, c.y, c.z];
+    const q = this.q.copy(b.root.quaternion);
+    const v = b.velocity;
+    const w = b.angularVelocity;
+    const [hx, hy, hz] = b.halfExtents;
+    const invM = 1 / b.mass;
+    const steps = clamp(Math.ceil(dt / SUB_DT), 1, 8);
+    const h = dt / steps;
+    let landing = 0;
+    let landPoint = [pos[0], pos[1], pos[2]];
+    let contactedLast = false;
+    let touched = false;
+    let unstable = false;
+    for (let s = 0; s < steps; s++) {
+      v[1] -= this.o.gravity * h;
+      pos[0] += v[0] * h;
+      pos[1] += v[1] * h;
+      pos[2] += v[2] * h;
+      const wl = Math.hypot(w[0], w[1], w[2]);
+      if (wl > 1e-6) {
+        this.dq.setFromAxisAngle(this.ax.set(w[0] / wl, w[1] / wl, w[2] / wl), wl * h);
+        q.premultiply(this.dq).normalize();
+      }
+      const damp = Math.exp(-0.15 * h);
+      w[0] *= damp;
+      w[1] *= damp;
+      w[2] *= damp;
+      this.m.makeRotationFromQuaternion(q);
+      const e = this.m.elements;
+      const rs = [];
+      let maxPen = 0;
+      for (let i = 0; i < 8; i++) {
+        const sx = i & 1 ? hx : -hx;
+        const sy = i & 2 ? hy : -hy;
+        const sz = i & 4 ? hz : -hz;
+        const r = [e[0] * sx + e[4] * sy + e[8] * sz, e[1] * sx + e[5] * sy + e[9] * sz, e[2] * sx + e[6] * sy + e[10] * sz];
+        const gy = this.o.groundAt(pos[0] + r[0], pos[2] + r[2]);
+        const pen = gy - (pos[1] + r[1]);
+        if (pen > -SLOP) {
+          rs.push(r);
+          if (pen > maxPen) maxPen = pen;
+        }
+      }
+      contactedLast = rs.length > 0;
+      if (contactedLast) touched = true;
+      if (!contactedLast) continue;
+      pos[1] += Math.max(0, maxPen - SLOP * 0.5);
+      let impact = 0;
+      for (const r of rs) impact = Math.max(impact, -(v[1] + w[2] * r[0] - w[0] * r[2]));
+      const restitution = impact > 2 ? 0.25 : 0;
+      if (impact > landing) {
+        landing = impact;
+        let sx = 0;
+        let sz = 0;
+        for (const r of rs) {
+          sx += r[0];
+          sz += r[2];
+        }
+        const lx = pos[0] + sx / rs.length;
+        const lz = pos[2] + sz / rs.length;
+        landPoint = [lx, this.o.groundAt(lx, lz), lz];
+      }
+      for (let it = 0; it < 4; it++) {
+        for (const r of rs) {
+          let vx = v[0] + (w[1] * r[2] - w[2] * r[1]);
+          let vy = v[1] + (w[2] * r[0] - w[0] * r[2]);
+          let vz = v[2] + (w[0] * r[1] - w[1] * r[0]);
+          const vn = vy;
+          if (vn >= 0) continue;
+          const a = this.mulInvInertiaWith(b, e, -r[2], 0, r[0]);
+          const denom = invM + (a[2] * r[0] - a[0] * r[2]);
+          const j = -(1 + (it === 0 ? restitution : 0)) * vn / denom;
+          v[1] += j * invM;
+          const dw = this.mulInvInertiaWith(b, e, -r[2] * j, 0, r[0] * j);
+          w[0] += dw[0];
+          w[1] += dw[1];
+          w[2] += dw[2];
+          vx = v[0] + (w[1] * r[2] - w[2] * r[1]);
+          vy = v[1] + (w[2] * r[0] - w[0] * r[2]);
+          vz = v[2] + (w[0] * r[1] - w[1] * r[0]);
+          const vt = Math.hypot(vx, vz);
+          if (vt > 1e-5) {
+            const tx = vx / vt;
+            const tz = vz / vt;
+            const rx = r[1] * tz;
+            const ry = r[2] * tx - r[0] * tz;
+            const rz = -r[1] * tx;
+            const at = this.mulInvInertiaWith(b, e, rx, ry, rz);
+            const cx = at[1] * r[2] - at[2] * r[1];
+            const cz = at[0] * r[1] - at[1] * r[0];
+            const denomT = invM + cx * tx + cz * tz;
+            const jt = Math.min(vt / denomT, MU * j);
+            v[0] -= tx * jt * invM;
+            v[2] -= tz * jt * invM;
+            const dwt = this.mulInvInertiaWith(b, e, rx * jt, ry * jt, rz * jt);
+            w[0] -= dwt[0];
+            w[1] -= dwt[1];
+            w[2] -= dwt[2];
+          }
+        }
+      }
+      let x0 = Infinity, x1 = -Infinity, z0 = Infinity, z1 = -Infinity, low = 0;
+      for (const r of rs) {
+        x0 = Math.min(x0, r[0]);
+        x1 = Math.max(x1, r[0]);
+        z0 = Math.min(z0, r[2]);
+        z1 = Math.max(z1, r[2]);
+        low = Math.min(low, r[1]);
+      }
+      const height = -low;
+      const wx = x1 - x0;
+      const wz = z1 - z0;
+      unstable = Math.min(wx, wz) < NARROW * height || x0 > 0 || x1 < 0 || z0 > 0 || z1 < 0;
+      if (unstable) {
+        const dirX = x0 + x1 > 0 ? -1 : 1;
+        const dirZ = z0 + z1 > 0 ? -1 : 1;
+        const k = TOPPLE * Math.min(height, 1) * h;
+        if (wx <= wz) w[2] -= dirX * k;
+        else w[0] += dirZ * k;
+      }
+      const rd = Math.exp((rs.length >= 3 ? -3 : -1.5) * h);
+      w[0] *= rd;
+      w[1] *= rd;
+      w[2] *= rd;
+      const fd = Math.exp(-0.3 * h);
+      v[0] *= fd;
+      v[2] *= fd;
+    }
+    b.root.quaternion.copy(q);
+    const off = this.ax.copy(b.centerV).applyQuaternion(q);
+    b.root.position.set(pos[0] - off.x, pos[1] - off.y, pos[2] - off.z);
+    b.root.updateMatrixWorld(true);
+    b.onGround = contactedLast;
+    if (landing > HARD_LANDING && this.time - b.lastHit > 0.15) {
+      b.lastHit = this.time;
+      this.o.onHardLanding(b, landPoint, landing);
+    }
+    const still = touched && !unstable && Math.hypot(v[0], v[1], v[2]) < 0.12 && Math.hypot(w[0], w[1], w[2]) < 0.45;
+    if (still) {
+      b.still += dt;
+      if (b.still >= SLEEP_AFTER) {
+        b.sleeping = true;
+        v[0] = v[1] = v[2] = 0;
+        w[0] = w[1] = w[2] = 0;
+      }
+    } else {
+      b.still = 0;
+    }
+  }
+  /** Push overlapping pieces apart (horizontal bounding circles), gently, so they do not interpenetrate forever. */
+  separate(dt) {
+    const n = this.list.length;
+    if (n < 2) return;
+    const maxMove = 1.5 * dt;
+    const ca = new this.THREE.Vector3();
+    const cb = new this.THREE.Vector3();
+    for (let i = 0; i < n; i++) {
+      const a = this.list[i];
+      for (let j = i + 1; j < n; j++) {
+        const b = this.list[j];
+        if (a.held && b.held) continue;
+        if (a.sleeping && b.sleeping) continue;
+        const ra = Math.hypot(a.halfExtents[0], a.halfExtents[1], a.halfExtents[2]);
+        const rb = Math.hypot(b.halfExtents[0], b.halfExtents[1], b.halfExtents[2]);
+        this.centerOf(a, ca);
+        this.centerOf(b, cb);
+        if (Math.abs(ca.y - cb.y) > ra + rb) continue;
+        const rh = (Math.max(a.halfExtents[0], a.halfExtents[2]) + Math.max(b.halfExtents[0], b.halfExtents[2])) * 0.8;
+        let dx = cb.x - ca.x;
+        let dz = cb.z - ca.z;
+        let d = Math.hypot(dx, dz);
+        if (d >= rh) continue;
+        if (d < 1e-5) {
+          dx = 1;
+          dz = 0;
+          d = 1;
+        }
+        const push = Math.min(maxMove, (rh - d) * 0.5);
+        const wa = a.held ? 0 : b.held ? 1 : b.mass / (a.mass + b.mass);
+        const wb = b.held ? 0 : a.held ? 1 : a.mass / (a.mass + b.mass);
+        const ux = dx / (d || 1);
+        const uz = dz / (d || 1);
+        if (!a.held) {
+          a.root.position.x -= ux * push * 2 * wa;
+          a.root.position.z -= uz * push * 2 * wa;
+          a.sleeping = false;
+        }
+        if (!b.held) {
+          b.root.position.x += ux * push * 2 * wb;
+          b.root.position.z += uz * push * 2 * wb;
+          b.sleeping = false;
+        }
+      }
+    }
+  }
+};
+
+// src/spec.ts
+import { guessMaterial, inferJoints } from "@adatechnology/game-destruction";
+function partHintOf(value) {
+  if (typeof value === "string") return value ? { id: value } : null;
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  if (typeof v.id !== "string" || !v.id) return null;
+  const str = (x) => typeof x === "string" && x ? x : void 0;
+  return { id: v.id, material: str(v.material), parent: str(v.parent), kind: str(v.kind) };
+}
+var METAL = /steel|iron|metal|alumin|copper|brass|bronze|tin|titan|chrome|zinc|lead/i;
+function sanitizeId(name) {
+  let id = name.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  if (id && /^[0-9]/.test(id)) id = `p_${id}`;
+  return id;
+}
+function isMesh(o) {
+  return o.isMesh === true;
+}
+function sizeOf(box) {
+  return [box.max.x - box.min.x, box.max.y - box.min.y, box.max.z - box.min.z];
+}
+function specFromObject3D(THREE, root, options = {}) {
+  const fallback = options.fallback ?? "plastic";
+  const minSize = options.minSize ?? 0.015;
+  root.updateMatrixWorld(true);
+  const inv = root.matrixWorld.clone().invert();
+  const entries = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const visit = (o) => {
+    if (!o.visible || o.userData?.destructionIgnore) return;
+    if (isMesh(o) && o.geometry) {
+      const geom = o.geometry;
+      if (!geom.boundingBox) geom.computeBoundingBox();
+      if (geom.boundingBox && !geom.boundingBox.isEmpty()) {
+        const box = geom.boundingBox.clone().applyMatrix4(new THREE.Matrix4().multiplyMatrices(inv, o.matrixWorld));
+        const mats = Array.isArray(o.material) ? o.material : [o.material];
+        const matName = mats[0]?.name ?? "";
+        const ud = o.userData ?? {};
+        const hint = partHintOf(ud.destructionPart);
+        const material = options.materialOf?.(o) ?? (typeof ud.destructionMaterial === "string" ? ud.destructionMaterial : void 0) ?? hint?.material ?? guessMaterial(`${o.name} ${matName} ${typeof ud.material === "string" ? ud.material : ""}`) ?? fallback;
+        const explicit = hint?.id ?? null;
+        const hollow = ud.hollow === true || /hollow/i.test(o.name);
+        const fill = options.fillOf?.(o, material);
+        const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
+        const existing = explicit ? byKey.get(explicit) : void 0;
+        if (existing) {
+          const before = sizeOf(existing.box);
+          const bv = before[0] * before[1] * before[2];
+          const ns = sizeOf(box);
+          existing.box.union(box);
+          existing.meshes.push(o);
+          if (ns[0] * ns[1] * ns[2] > bv) existing.material = material;
+          existing.hollow = existing.hollow || hollow;
+          if (fill !== void 0) existing.fill = fill;
+        } else {
+          const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, tags, fixedId: !!explicit, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
+          entries.push(e);
+          if (explicit) byKey.set(explicit, e);
+        }
+      }
+    }
+    for (const c of o.children) visit(c);
+  };
+  visit(root);
+  const eps = 5e-3;
+  const overlapVolume = (a, b) => {
+    const x = Math.min(a.max.x, b.max.x) - Math.max(a.min.x, b.min.x) + eps;
+    const y = Math.min(a.max.y, b.max.y) - Math.max(a.min.y, b.min.y) + eps;
+    const z = Math.min(a.max.z, b.max.z) - Math.max(a.min.z, b.min.z) + eps;
+    return x > 0 && y > 0 && z > 0 ? x * y * z : 0;
+  };
+  const largest = (e) => Math.max(...sizeOf(e.box));
+  const kept = [];
+  const tiny = [];
+  for (const e of entries) (!e.fixedId && largest(e) < minSize ? tiny : kept).push(e);
+  for (const t of tiny) {
+    let best = null;
+    let bestV = 0;
+    for (const k of kept) {
+      const v = overlapVolume(t.box, k.box);
+      if (v > bestV) {
+        bestV = v;
+        best = k;
+      }
+    }
+    if (!best) {
+      let bd = 0.05;
+      for (const k of kept) {
+        const d = k.box.distanceToPoint(t.box.getCenter(new THREE.Vector3()));
+        if (d < bd) {
+          bd = d;
+          best = k;
+        }
+      }
+    }
+    if (best) {
+      best.meshes.push(...t.meshes);
+    } else {
+      kept.push(t);
+    }
+  }
+  const used = /* @__PURE__ */ new Set();
+  const parts = [];
+  const meshesOf = {};
+  let counter = 0;
+  for (const e of kept) {
+    counter++;
+    let base = (e.explicitId ? sanitizeId(e.explicitId) : "") || sanitizeId(e.name) || `part_${counter}`;
+    let id = base;
+    for (let n = 2; used.has(id); n++) id = `${base}_${n}`;
+    used.add(id);
+    base = id;
+    const size = sizeOf(e.box);
+    const center = e.box.getCenter(new THREE.Vector3());
+    const part = {
+      id,
+      material: e.material,
+      shape: { kind: "box", size: [Math.max(size[0], 2e-3), Math.max(size[1], 2e-3), Math.max(size[2], 2e-3)] },
+      position: [center.x, center.y, center.z]
+    };
+    const minSide = Math.min(...size);
+    if (e.fill !== void 0) part.fill = e.fill;
+    else if (e.hollow) part.fill = 0.05;
+    if (minSide < 0.01 && METAL.test(e.material)) {
+      part.fill = e.fill ?? 1;
+      part.thickness = Math.max(minSide, 5e-4);
+    }
+    if (e.tags) part.tags = [...e.tags];
+    const ao = options.anchorBelow ?? -1;
+    if (ao >= 0 && e.box.min.y <= ao) part.anchored = true;
+    parts.push(part);
+    meshesOf[id] = e.meshes;
+  }
+  const spec = { parts };
+  if (options.name !== void 0) spec.name = options.name;
+  else if (root.name) spec.name = root.name;
+  if (options.tags) spec.tags = [...options.tags];
+  spec.joints = options.joints === false ? [] : inferJoints(parts);
+  if (options.joints !== false) {
+    const finalId = /* @__PURE__ */ new Map();
+    kept.forEach((e, i) => finalId.set(e, parts[i].id));
+    const idOf = /* @__PURE__ */ new Map();
+    for (const e of kept) if (e.explicitId) idOf.set(e.explicitId, finalId.get(e));
+    const joints = spec.joints;
+    for (const e of kept) {
+      if (!e.parent) continue;
+      const id = finalId.get(e);
+      const parent = idOf.get(e.parent) ?? (used.has(sanitizeId(e.parent)) ? sanitizeId(e.parent) : null);
+      if (!parent || parent === id) continue;
+      const at = joints.findIndex((j) => j.a === parent && j.b === id || j.a === id && j.b === parent);
+      const kind = e.jointKind ?? (at >= 0 ? joints[at].kind : "resting");
+      const joint = { id: `${parent}~${id}`, a: parent, b: id, kind };
+      if (at >= 0) joints[at] = joint;
+      else joints.push(joint);
+    }
+  }
+  return { spec, parts: meshesOf };
+}
+
+// src/heat.ts
+var STOPS = [
+  [450, 0],
+  [500, 2753536],
+  [650, 9049344],
+  [800, 14174728],
+  [950, 16747540],
+  [1100, 16761402],
+  [1250, 16771232],
+  [1400, 16777215]
+];
+function heatColor(temperatureC) {
+  if (!(temperatureC > STOPS[0][0])) return 0;
+  const last = STOPS[STOPS.length - 1];
+  if (temperatureC >= last[0]) return last[1];
+  for (let i = 1; i < STOPS.length; i++) {
+    const [t1, c1] = STOPS[i];
+    if (temperatureC <= t1) {
+      const [t0, c0] = STOPS[i - 1];
+      return mixHex(c0, c1, (temperatureC - t0) / (t1 - t0));
+    }
+  }
+  return last[1];
+}
+
+// src/visual.ts
+var POS_ATTR = "position";
+function positionAttr(geo) {
+  const a = geo.getAttribute(POS_ATTR);
+  return a && !a.isInterleavedBufferAttribute ? a : null;
+}
+function materialsOf(m) {
+  return Array.isArray(m) ? m : [m];
+}
+function colorOf(m) {
+  const c = m.color;
+  return c && c.isColor ? c : null;
+}
+var DecalKit = class {
+  constructor(THREE) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "disc", null);
+    __publicField(this, "discMat", null);
+    __publicField(this, "lineMats", /* @__PURE__ */ new Map());
+  }
+  discGeometry() {
+    return this.disc ?? (this.disc = new this.THREE.CircleGeometry(1, 14));
+  }
+  discMaterial() {
+    return this.discMat ?? (this.discMat = new this.THREE.MeshBasicMaterial({
+      color: 328965,
+      transparent: true,
+      opacity: 0.92,
+      depthWrite: false,
+      polygonOffset: true,
+      polygonOffsetFactor: -4,
+      polygonOffsetUnits: -4
+    }));
+  }
+  lineMaterial(color) {
+    let m = this.lineMats.get(color);
+    if (!m) {
+      m = new this.THREE.LineBasicMaterial({ color, transparent: true, opacity: 0.9, depthWrite: false });
+      this.lineMats.set(color, m);
+    }
+    return m;
+  }
+  dispose() {
+    this.disc?.dispose();
+    this.discMat?.dispose();
+    for (const m of this.lineMats.values()) m.dispose();
+    this.disc = null;
+    this.discMat = null;
+    this.lineMats.clear();
+  }
+};
+var tmpV = (THREE) => new THREE.Vector3();
+var Visuals = class {
+  constructor(THREE, lowQuality, decalCap) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "lowQuality", lowQuality);
+    __publicField(this, "decalCap", decalCap);
+    __publicField(this, "kit");
+    __publicField(this, "a");
+    __publicField(this, "b");
+    __publicField(this, "m4");
+    __publicField(this, "box");
+    /** Total live decals across meshes (kept in sync by add/remove). */
+    __publicField(this, "decalCount", 0);
+    __publicField(this, "tints", /* @__PURE__ */ new WeakMap());
+    this.kit = new DecalKit(THREE);
+    this.a = tmpV(THREE);
+    this.b = tmpV(THREE);
+    this.m4 = new THREE.Matrix4();
+    this.box = new THREE.Box3();
+  }
+  makeMeshVis(mesh, home) {
+    return {
+      mesh,
+      home,
+      origGeometry: mesh.geometry,
+      origMaterial: mesh.material,
+      origVisible: mesh.visible,
+      origParent: mesh.parent,
+      origPosition: mesh.position.clone(),
+      origQuaternion: mesh.quaternion.clone(),
+      origScale: mesh.scale.clone(),
+      ownMat: false,
+      ownGeo: false,
+      work: null,
+      baseColors: null,
+      decals: [],
+      meltApplied: 0,
+      bottomY: 0,
+      moved: false
+    };
+  }
+  vertexCount(mv) {
+    return mv.mesh.geometry.getAttribute(POS_ATTR)?.count ?? 0;
+  }
+  /**
+   * 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;
+    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) {
+      let r = 0, g = 0, b = 0;
+      for (let i = 0; i < attr.count; 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);
+    }
+    this.tints.set(mv.mesh, tint);
+    return tint;
+  }
+  /** Colour of the original material (before any char) times the vertex tint, `0xRRGGBB`, or -1. */
+  baseColorHex(mv) {
+    const c = mv.baseColors?.[0] ?? colorOf(materialsOf(mv.origMaterial)[0]);
+    if (!c) return -1;
+    const tint = this.vertexTint(mv);
+    return tint ? c.clone().multiply(tint).getHex() : c.getHex();
+  }
+  /** Is the original material transparent? */
+  isTransparent(mv) {
+    return materialsOf(mv.origMaterial).some((m) => m.transparent && m.opacity < 1);
+  }
+  ownMaterial(mv) {
+    if (mv.ownMat) return;
+    mv.ownMat = true;
+    const src = materialsOf(mv.origMaterial);
+    const cloned = src.map((m) => m.clone());
+    mv.baseColors = src.map((m) => colorOf(m)?.clone() ?? new this.THREE.Color(8947848));
+    mv.mesh.material = Array.isArray(mv.origMaterial) ? cloned : cloned[0];
+  }
+  /** Clone the geometry (vertex edits); false when its positions cannot be edited. */
+  ownGeometry(mv) {
+    if (mv.ownGeo) return true;
+    const pos = positionAttr(mv.mesh.geometry);
+    if (!pos) return false;
+    mv.ownGeo = true;
+    const g = mv.mesh.geometry.clone();
+    mv.mesh.geometry = g;
+    mv.work = new Float32Array(positionAttr(g).array);
+    return true;
+  }
+  // ------------------------------------------------------------------------------------------------------------------------------------
+  // Dents
+  // ------------------------------------------------------------------------------------------------------------------------------------
+  /**
+   * Push the vertices of the mesh within `dent.radius` of `worldPoint` inwards along `worldNormal` by `depth * (1 - (d/r)^2)^2`.
+   * Returns false when nothing was changed (too far, low quality on a heavy mesh, or no editable positions).
+   */
+  applyDent(mv, worldPoint, worldNormal, dent) {
+    const mesh = mv.mesh;
+    if (this.lowQuality && this.vertexCount(mv) > 2e4) return false;
+    mesh.updateWorldMatrix(true, false);
+    const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
+    const lp = mesh.worldToLocal(this.a.copy(worldPoint));
+    const ln = this.b.copy(worldNormal).transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
+    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;
+    if (!this.ownGeometry(mv)) return false;
+    const work = mv.work;
+    const pos = positionAttr(mesh.geometry);
+    const r2 = r * r;
+    let touched = false;
+    const px = lp.x;
+    const py = lp.y;
+    const pz = lp.z;
+    const nx = ln.x;
+    const ny = ln.y;
+    const nz = ln.z;
+    for (let i = 0; i < work.length; i += 3) {
+      const dx = work[i] - px;
+      const dy = work[i + 1] - py;
+      const dz = work[i + 2] - pz;
+      const d2 = dx * dx + dy * dy + dz * dz;
+      if (d2 >= r2) continue;
+      const f = 1 - d2 / r2;
+      const k = depth * f * f;
+      work[i] -= nx * k;
+      work[i + 1] -= ny * k;
+      work[i + 2] -= nz * k;
+      touched = true;
+    }
+    if (!touched) return false;
+    this.writePositions(mv, pos);
+    return true;
+  }
+  /** Copy `work` (dents) into the geometry, adding the melt sag when the mesh is melting. */
+  writePositions(mv, pos) {
+    const work = mv.work;
+    const arr = pos.array;
+    const melt = mv.meltApplied;
+    if (melt <= 0 || this.lowQuality && work.length / 3 > 2e4) {
+      arr.set(work);
+    } else {
+      const geo2 = mv.mesh.geometry;
+      if (!geo2.boundingBox) geo2.computeBoundingBox();
+      const bb = geo2.boundingBox;
+      const h = Math.max(1e-4, bb.max.y - bb.min.y);
+      const minY = bb.min.y;
+      for (let i = 0, v = 0; i < work.length; i += 3, v++) {
+        const n = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
+        const n2 = (Math.imul(v + 7, 40503) >>> 0) % 1e3 / 1e3;
+        const lowness = 1 - (work[i + 1] - minY) / h;
+        const spread = 1 + 0.12 * melt * (0.4 + n2) * (0.3 + lowness);
+        arr[i] = work[i] * spread;
+        arr[i + 2] = work[i + 2] * spread;
+        arr[i + 1] = Math.max(minY, work[i + 1] - n * melt * h * 0.08);
+      }
+    }
+    pos.needsUpdate = true;
+    const geo = mv.mesh.geometry;
+    geo.computeVertexNormals();
+    geo.boundingBox = null;
+    geo.boundingSphere = null;
+  }
+  // ------------------------------------------------------------------------------------------------------------------------------------
+  // Decals
+  // ------------------------------------------------------------------------------------------------------------------------------------
+  /** Decal pose in mesh space: position and a rotation taking +Z to the surface normal. */
+  decalPose(mesh, worldPoint, worldNormal, lift) {
+    mesh.updateWorldMatrix(true, false);
+    const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
+    const ln = worldNormal.clone().transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
+    const pos = mesh.worldToLocal(worldPoint.clone()).addScaledVector(ln, lift / s);
+    const quat = new this.THREE.Quaternion().setFromUnitVectors(new this.THREE.Vector3(0, 0, 1), ln);
+    return { s, pos, quat };
+  }
+  addDecal(mv, decal) {
+    mv.mesh.add(decal.obj);
+    mv.decals.push(decal);
+    this.decalCount++;
+    while (mv.decals.length > 48 || this.decalCount > this.decalCap) {
+      const old = mv.decals.shift();
+      if (!old) break;
+      this.disposeDecal(old);
+    }
+  }
+  disposeDecal(d) {
+    d.obj.parent?.remove(d.obj);
+    d.geometry?.dispose();
+    this.decalCount = Math.max(0, this.decalCount - 1);
+  }
+  addHole(mv, worldPoint, worldNormal, diameter) {
+    const { s, pos, quat } = this.decalPose(mv.mesh, worldPoint, worldNormal, 25e-4);
+    const disc = new this.THREE.Mesh(this.kit.discGeometry(), this.kit.discMaterial());
+    disc.position.copy(pos);
+    disc.quaternion.copy(quat);
+    disc.scale.setScalar(Math.max(4e-3, diameter) * 0.5 * 1.25 / s);
+    disc.renderOrder = 2;
+    this.addDecal(mv, { obj: disc });
+  }
+  /** A star of jagged lines: `rays` rays up to `length` metres, seeded so the same event always draws the same star. */
+  addCrack(mv, worldPoint, worldNormal, rays, length, color, seed) {
+    const { s, pos, quat } = this.decalPose(mv.mesh, worldPoint, worldNormal, 2e-3);
+    const rnd = createRng(seed);
+    const verts = [];
+    const n = clamp(Math.round(rays), 3, 16);
+    const L = Math.max(0.02, length) / s;
+    for (let r = 0; r < n; r++) {
+      let ang = r / n * Math.PI * 2 + (rnd() - 0.5) * 0.5;
+      let x = 0;
+      let y = 0;
+      const segs = 3;
+      const total = L * (0.6 + 0.4 * rnd());
+      for (let k = 0; k < segs; k++) {
+        const step = total / segs * (0.7 + 0.6 * rnd());
+        ang += (rnd() - 0.5) * 0.45;
+        const nx = x + Math.cos(ang) * step;
+        const ny = y + Math.sin(ang) * step;
+        verts.push(x, y, 0, nx, ny, 0);
+        if (k > 0 && rnd() < 0.5) {
+          const ba = ang + (rnd() < 0.5 ? -1 : 1) * (0.5 + rnd() * 0.5);
+          const bl = step * (0.6 + 0.6 * rnd());
+          verts.push(nx, ny, 0, nx + Math.cos(ba) * bl, ny + Math.sin(ba) * bl, 0);
+        }
+        x = nx;
+        y = ny;
+      }
+    }
+    const ringR = L * 0.12;
+    for (let k = 0; k < 8; k++) {
+      const a0 = k / 8 * Math.PI * 2;
+      const a1 = (k + 1) / 8 * Math.PI * 2;
+      if (rnd() < 0.75) verts.push(Math.cos(a0) * ringR, Math.sin(a0) * ringR, 0, Math.cos(a1) * ringR, Math.sin(a1) * ringR, 0);
+    }
+    const geo = new this.THREE.BufferGeometry();
+    geo.setAttribute("position", new this.THREE.Float32BufferAttribute(verts, 3));
+    const lines = new this.THREE.LineSegments(geo, this.kit.lineMaterial(color));
+    lines.position.copy(pos);
+    lines.quaternion.copy(quat);
+    lines.renderOrder = 2;
+    this.addDecal(mv, { obj: lines, geometry: geo });
+  }
+  // ------------------------------------------------------------------------------------------------------------------------------------
+  // Char and heat glow
+  // ------------------------------------------------------------------------------------------------------------------------------------
+  setChar(pv, char, charColor) {
+    if (Math.abs(char - pv.charApplied) < 4e-3) return;
+    pv.charApplied = char;
+    const target = new this.THREE.Color(charColor);
+    for (const mv of pv.meshes) {
+      this.ownMaterial(mv);
+      const mats = materialsOf(mv.mesh.material);
+      mats.forEach((m, i) => {
+        const c = colorOf(m);
+        const base = mv.baseColors?.[i];
+        if (c && base) c.copy(base).lerp(target, clamp(char, 0, 1));
+      });
+    }
+  }
+  /** Emissive glow of a hot part. `temperature` below the glow threshold switches it off. */
+  setGlow(pv, temperatureC) {
+    const hex = heatColor(temperatureC);
+    const key = hex === 0 ? 0 : Math.round(temperatureC / 5) * 5;
+    if (key === pv.glowApplied) return;
+    pv.glowApplied = key;
+    const intensity = hex === 0 ? 0 : clamp(0.35 + (temperatureC - 450) / 900, 0, 1.4);
+    for (const mv of pv.meshes) {
+      this.ownMaterial(mv);
+      for (const m of materialsOf(mv.mesh.material)) {
+        const e = m.emissive;
+        if (e && e.isColor) {
+          e.setHex(hex);
+          m.emissiveIntensity = intensity;
+        }
+      }
+    }
+  }
+  // ------------------------------------------------------------------------------------------------------------------------------------
+  // Melt
+  // ------------------------------------------------------------------------------------------------------------------------------------
+  /** Sag the part: shorter in Y (down to 25 %), a bit wider, vertices pushed down with noise, the bottom stays put. */
+  setMelt(pv, melt) {
+    const m = clamp(melt, 0, 1);
+    if (Math.abs(m - pv.meltApplied) < 0.01) return;
+    pv.meltApplied = m;
+    for (const mv of pv.meshes) {
+      const mesh = mv.mesh;
+      if (mv.meltApplied === 0 && m > 0) {
+        mesh.updateWorldMatrix(true, false);
+        mv.bottomY = this.box.setFromObject(mesh).min.y;
+      }
+      mv.meltApplied = m;
+      mv.moved = true;
+      const sy = lerp(1, 0.25, m);
+      const sxz = 1 + 0.18 * m;
+      mesh.scale.set(mv.origScale.x * sxz, mv.origScale.y * sy, mv.origScale.z * sxz);
+      mesh.position.copy(mv.origPosition);
+      mesh.updateWorldMatrix(true, false);
+      const bottom = this.box.setFromObject(mesh).min.y;
+      const dy = mv.bottomY - bottom;
+      if (Math.abs(dy) > 1e-6 && mesh.parent) {
+        mesh.parent.updateWorldMatrix(true, false);
+        const inv = this.m4.copy(mesh.parent.matrixWorld).invert();
+        this.a.set(0, dy, 0).applyMatrix4(inv);
+        this.b.set(0, 0, 0).applyMatrix4(inv);
+        mesh.position.copy(mv.origPosition).add(this.a.sub(this.b));
+      }
+      if (!(this.lowQuality && this.vertexCount(mv) > 2e4) && this.ownGeometry(mv)) {
+        this.writePositions(mv, positionAttr(mesh.geometry));
+      }
+    }
+  }
+  // ------------------------------------------------------------------------------------------------------------------------------------
+  // Visibility and restore
+  // ------------------------------------------------------------------------------------------------------------------------------------
+  hide(pv, reason) {
+    pv.gone = reason;
+    for (const mv of pv.meshes) mv.mesh.visible = false;
+  }
+  /** Bring one mesh back to how it was when it was bound. */
+  restoreMesh(mv) {
+    const mesh = mv.mesh;
+    for (const d of mv.decals) this.disposeDecal(d);
+    mv.decals.length = 0;
+    if (mv.ownGeo) {
+      mesh.geometry.dispose();
+      mesh.geometry = mv.origGeometry;
+      mv.ownGeo = false;
+      mv.work = null;
+    }
+    if (mv.ownMat) {
+      for (const m of materialsOf(mesh.material)) m.dispose();
+      mesh.material = mv.origMaterial;
+      mv.ownMat = false;
+      mv.baseColors = null;
+    }
+    mesh.visible = mv.origVisible;
+    if (mv.origParent && mesh.parent !== mv.origParent) {
+      mv.origParent.add(mesh);
+      mv.moved = true;
+    }
+    if (mv.moved) {
+      mesh.position.copy(mv.origPosition);
+      mesh.quaternion.copy(mv.origQuaternion);
+      mesh.scale.copy(mv.origScale);
+      mv.moved = false;
+    }
+    mv.meltApplied = 0;
+  }
+  restorePart(pv) {
+    for (const mv of pv.meshes) this.restoreMesh(mv);
+    pv.charApplied = 0;
+    pv.glowApplied = 0;
+    pv.meltApplied = 0;
+    pv.gone = "none";
+  }
+  dispose() {
+    this.kit.dispose();
+  }
+};
+
+// src/renderer.ts
+var GLOW_FROM_C = 430;
+var QUEUE_CAP = 4e3;
+var FLUID_COLORS = {
+  water: 9226495,
+  fuel: 14262322,
+  oil: 2760728,
+  gas: 15921906,
+  sap: 12098362,
+  acid: 10211900,
+  blood: 9046538
+};
+var SMOKE_TONES = { white: 15132390, grey: 9079434, black: 2763306 };
+var DEFAULT_SPEED = {
+  sparks: 3,
+  splinters: 2.5,
+  dust: 1,
+  shards: 2.5,
+  fibers: 1.2,
+  leaves: 1.2,
+  drips: 0.5,
+  ash: 0.8,
+  chips: 2.5,
+  smoke: 0.8,
+  steam: 1,
+  fire: 1.2,
+  flash: 0,
+  foam: 2.5
+};
+function impactKey(def) {
+  if (!def) return "impact_wood";
+  const tags = def.tags ?? [];
+  if (tags.includes("metal")) return "impact_metal";
+  if (def.visual?.transparent || def.fracture === "shatter") return "impact_glass";
+  if (def.fracture === "crumble") return "impact_masonry";
+  if (def.fracture === "tear") return "impact_soft";
+  return def.fracture === "none" ? "impact_metal" : "impact_wood";
+}
+function fractureKey(def, style) {
+  switch (style) {
+    case "shatter":
+      return "shatter_glass";
+    case "crumble":
+      return "crumble";
+    case "splinter":
+      return "splinter";
+    default:
+      return impactKey(def);
+  }
+}
+function fallbackColor(id, def) {
+  if (def?.tags?.includes("metal")) return 9080726;
+  if (def?.visual?.transparent) return 10473696;
+  const h = hashString(id);
+  return mixHex(7035464, 10130568, h % 100 / 100);
+}
+function materialsOf2(m) {
+  return Array.isArray(m) ? m : [m];
+}
+function createDestructionRenderer(THREE, options) {
+  return new Renderer(THREE, options);
+}
+var Renderer = class {
+  constructor(THREE, o) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "o", o);
+    __publicField(this, "world");
+    __publicField(this, "scene");
+    __publicField(this, "quality");
+    __publicField(this, "low");
+    __publicField(this, "groundAt");
+    __publicField(this, "gravity");
+    __publicField(this, "autoSplit");
+    __publicField(this, "maxFragments");
+    __publicField(this, "bounds", /* @__PURE__ */ new Map());
+    __publicField(this, "queue", []);
+    __publicField(this, "unsubscribe");
+    __publicField(this, "visuals");
+    __publicField(this, "particles");
+    __publicField(this, "fragments");
+    __publicField(this, "ground");
+    __publicField(this, "pieceSys");
+    __publicField(this, "active", /* @__PURE__ */ new Map());
+    __publicField(this, "fires", /* @__PURE__ */ new Map());
+    __publicField(this, "leaks", []);
+    __publicField(this, "homeTags", []);
+    __publicField(this, "throttles", /* @__PURE__ */ new Map());
+    __publicField(this, "rng", createRng(12648430));
+    __publicField(this, "light", null);
+    __publicField(this, "lightT", 0);
+    __publicField(this, "lightDur", 0.3);
+    __publicField(this, "lightPeak", 0);
+    __publicField(this, "time", 0);
+    __publicField(this, "scanTimer", 0);
+    __publicField(this, "disposed", false);
+    __publicField(this, "box");
+    __publicField(this, "tmpQ");
+    __publicField(this, "v1");
+    __publicField(this, "v2");
+    this.world = o.world;
+    this.scene = o.scene;
+    this.quality = o.quality ?? "medium";
+    this.low = this.quality === "low";
+    this.groundAt = o.groundAt ?? (() => 0);
+    this.gravity = o.gravity ?? 9.81;
+    this.autoSplit = o.autoSplit !== false;
+    this.maxFragments = o.maxFragments ?? 160;
+    this.box = new THREE.Box3();
+    this.tmpQ = new THREE.Quaternion();
+    this.v1 = new THREE.Vector3();
+    this.v2 = new THREE.Vector3();
+    const maxParticles = Math.max(8, Math.floor((o.maxParticles ?? 2500) * (this.low ? 0.5 : 1)));
+    this.visuals = new Visuals(THREE, this.low, 600);
+    this.ground = new GroundSpots(THREE, o.scene, this.groundAt, 48);
+    this.particles = new ParticleSystem(THREE, {
+      capacity: maxParticles,
+      scene: o.scene,
+      density: this.low ? 0.6 : 1,
+      pointScale: o.pointScale ?? 700,
+      groundAt: this.groundAt,
+      gravity: this.gravity,
+      onLand: (x, _y, z, color, tag) => {
+        const home = this.homeTags[tag - 1] ?? "";
+        this.ground.add("puddle", x, z, 0.05 + this.rng() * 0.04, color, home);
+      }
+    });
+    this.fragments = new FragmentSystem(THREE, {
+      scene: o.scene,
+      groundAt: this.groundAt,
+      gravity: this.gravity,
+      max: this.maxFragments,
+      life: o.fragmentLife ?? 12
+    });
+    this.pieceSys = new PieceSystem(THREE, {
+      groundAt: this.groundAt,
+      gravity: this.gravity,
+      scene: o.scene,
+      onHardLanding: (p, point, speed) => this.hardLanding(p, point, speed)
+    });
+    this.unsubscribe = this.world.on("*", (ev) => {
+      if (this.queue.length < QUEUE_CAP) this.queue.push(ev);
+    });
+  }
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  // Binding
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  bind(objectId, root, options = {}) {
+    if (this.bounds.has(objectId)) this.unbind(objectId);
+    const state = this.world.state(objectId);
+    const partIds = new Set((state?.parts ?? []).map((p) => p.id));
+    const byPart = /* @__PURE__ */ new Map();
+    const taken = /* @__PURE__ */ new Set();
+    const add = (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]);
+    };
+    const meshesIn = (o) => {
+      const out = [];
+      o.traverse((c) => {
+        if (c.isMesh) out.push(c);
+      });
+      return out;
+    };
+    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)) add(pid, m);
+      }
+    } else {
+      const leftovers = [];
+      for (const m of meshesIn(root)) {
+        const ud = partHintOf(m.userData?.destructionPart)?.id;
+        if (ud !== void 0 && partIds.has(ud)) add(ud, m);
+        else if (partIds.has(m.name)) add(m.name, m);
+        else leftovers.push(m);
+      }
+      if (leftovers.length) this.matchByBox(objectId, root, leftovers, add);
+    }
+    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) ?? []));
+    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));
+    }
+    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" };
+  }
+  /** Match unlabelled meshes to the part whose shape contains the centre of the mesh's bounding box. */
+  matchByBox(objectId, root, meshes, add) {
+    let specParts;
+    try {
+      specParts = this.world.serialize?.().objects.find((o) => o.id === objectId)?.spec.parts;
+    } catch {
+      specParts = void 0;
+    }
+    if (!specParts) return;
+    root.updateMatrixWorld(true);
+    const e = new this.THREE.Euler();
+    const q = new this.THREE.Quaternion();
+    for (const m of meshes) {
+      this.box.setFromObject(m);
+      if (this.box.isEmpty()) continue;
+      const c = root.worldToLocal(this.box.getCenter(this.v1));
+      let best = null;
+      let bestVol = Infinity;
+      for (const p of specParts) {
+        const l = this.v2.set(c.x - p.position[0], c.y - p.position[1], c.z - p.position[2]);
+        if (p.rotation) l.applyQuaternion(q.setFromEuler(e.set(p.rotation[0], p.rotation[1], p.rotation[2], "XYZ")).invert());
+        let inside = false;
+        let vol = 0;
+        const s = p.shape;
+        if (s.kind === "box") {
+          inside = Math.abs(l.x) <= s.size[0] / 2 && Math.abs(l.y) <= s.size[1] / 2 && Math.abs(l.z) <= s.size[2] / 2;
+          vol = s.size[0] * s.size[1] * s.size[2];
+        } else if (s.kind === "cylinder") {
+          inside = Math.hypot(l.x, l.z) <= s.radius && Math.abs(l.y) <= s.height / 2;
+          vol = Math.PI * s.radius * s.radius * s.height;
+        } else {
+          inside = l.length() <= s.radius;
+          vol = 4 / 3 * Math.PI * s.radius ** 3;
+        }
+        if (inside && vol < bestVol) {
+          best = p;
+          bestVol = vol;
+        }
+      }
+      if (best) add(best.id, m);
+    }
+  }
+  unbind(objectId) {
+    const b = this.bounds.get(objectId);
+    if (!b) return;
+    this.restore(objectId);
+    this.pieceSys.remove(objectId);
+    this.bounds.delete(objectId);
+  }
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  // Pieces
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  /** Half extents and centre of the box around some meshes, in the local space of `root`. */
+  measure(root, meshes) {
+    root.updateMatrixWorld(true);
+    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)));
+    }
+    if (total.isEmpty()) return { half: [0.25, 0.25, 0.25], center: new this.THREE.Vector3() };
+    const size = total.getSize(new this.THREE.Vector3());
+    return { half: [Math.max(0.02, size.x / 2), Math.max(0.02, size.y / 2), Math.max(0.02, size.z / 2)], center: total.getCenter(new this.THREE.Vector3()) };
+  }
+  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);
+    return out;
+  }
+  massOf(objectId) {
+    const st = this.world.state(objectId);
+    if (!st) return 5;
+    let m = 0;
+    for (const p of st.parts) if (p.status !== "broken" && p.status !== "melted" && p.status !== "ashes") m += p.mass;
+    return m > 0 ? m : 5;
+  }
+  makePiece(objectId, options = {}) {
+    const b = this.bounds.get(objectId);
+    if (!b) throw new Error(`game-destruction-three: object "${objectId}" is not bound`);
+    if (b.root.parent && b.root.parent !== this.scene) this.scene.attach(b.root);
+    const { half, center } = this.measure(b.root, this.meshesOf(b));
+    const piece = this.pieceSys.create(objectId, b.root, half, center, options.mass ?? this.massOf(objectId), options.velocity);
+    b.piece = piece;
+    return piece;
+  }
+  pieces() {
+    return [...this.pieceSys.list];
+  }
+  piece(objectId) {
+    return this.pieceSys.get(objectId);
+  }
+  impulse(objectId, impulse, point) {
+    const p = this.pieceSys.get(objectId);
+    if (p) this.pieceSys.impulse(p, impulse, point);
+  }
+  hardLanding(p, point, speed) {
+    const key = this.impactSoundOf(p.objectId);
+    this.sound(key, point, clamp(speed / 10, 0.2, 1));
+    this.syncBound(p.objectId);
+    try {
+      this.world.hit(p.objectId, { type: "blunt", point, energy: 0.5 * p.mass * speed * speed, radius: 0.08, direction: [0, -1, 0], source: "fall" });
+    } catch {
+    }
+  }
+  impactSoundOf(objectId) {
+    const st = this.world.state(objectId);
+    let best;
+    let mass = -1;
+    for (const p of st?.parts ?? []) {
+      if (p.mass > mass) {
+        mass = p.mass;
+        best = this.world.materials.get(p.material);
+      }
+    }
+    return impactKey(best);
+  }
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  // Update
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  update(dt) {
+    if (this.disposed) return;
+    dt = clamp(dt, 0, 0.1);
+    this.time += dt;
+    this.drainQueue();
+    this.updateActive(dt);
+    this.updateLeaks(dt);
+    this.pieceSys.update(dt);
+    this.fragments.update(dt);
+    this.ground.update(dt);
+    this.updateLight(dt);
+    this.particles.update(dt);
+    this.syncTransforms();
+  }
+  drainQueue() {
+    const batch = this.queue.splice(0, this.queue.length);
+    for (const ev of batch) {
+      try {
+        this.apply(ev);
+      } catch (err) {
+        if (typeof console !== "undefined") console.error("game-destruction-three: failed to apply", ev.type, err);
+      }
+    }
+  }
+  syncTransforms() {
+    for (const b of this.bounds.values()) this.syncOne(b);
+  }
+  /** Push the current transform of one bound object to the world right now (used before a landing hit). */
+  syncBound(objectId) {
+    const b = this.bounds.get(objectId);
+    if (b) this.syncOne(b);
+  }
+  syncOne(b) {
+    if (!b.sync) return;
+    const p = this.v1;
+    const q = this.tmpQ;
+    b.root.updateWorldMatrix(true, false);
+    b.root.matrixWorld.decompose(p, q, this.v2);
+    const last = b.lastPos;
+    const lq = b.lastQuat;
+    const moved = !last || !lq || Math.abs(p.x - last[0]) + Math.abs(p.y - last[1]) + Math.abs(p.z - last[2]) > 1e-5 || Math.abs(q.x - lq[0]) + Math.abs(q.y - lq[1]) + Math.abs(q.z - lq[2]) + Math.abs(q.w - lq[3]) > 1e-6;
+    if (!moved) return;
+    b.lastPos = [p.x, p.y, p.z];
+    b.lastQuat = [q.x, q.y, q.z, q.w];
+    if (this.world.has(b.id)) this.world.setTransform(b.id, [p.x, p.y, p.z], [q.x, q.y, q.z, q.w]);
+  }
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  // Events
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  apply(ev) {
+    switch (ev.type) {
+      case "damage":
+        if (ev.damageType === "heat" || ev.damageType === "fire" || ev.damageType === "explosive") this.activate(ev.object, ev.part);
+        break;
+      case "dent":
+        this.onDent(ev);
+        break;
+      case "hole":
+        this.onHole(ev);
+        break;
+      case "crack":
+        this.onCrack(ev);
+        break;
+      case "ricochet": {
+        const d = ev.direction;
+        this.particles.burst("sparks", ev.point, d, 4 + Math.min(10, ev.energy / 150), 4);
+        this.sound("ricochet", ev.point, 0.7);
+        break;
+      }
+      case "debris":
+        this.particles.burst(ev.kind, ev.point, ev.normal, ev.count, ev.speed > 0 ? ev.speed : DEFAULT_SPEED[ev.kind] ?? 1, this.debrisOptions(ev.kind, ev.object, ev.part));
+        break;
+      case "fracture":
+        this.onFracture(ev);
+        break;
+      case "detach":
+        this.onDetach(ev);
+        break;
+      case "disassemble_progress": {
+        const k = `unscrew:${ev.joint}`;
+        if (this.time - (this.throttles.get(k) ?? -1) > 0.25) {
+          this.throttles.set(k, this.time);
+          this.sound("unscrew", this.rootPoint(ev.object), clamp(0.3 + ev.progress * 0.5, 0, 1));
+        }
+        break;
+      }
+      case "ignite":
+        this.fires.set(`${ev.object}|${ev.part}`, { object: ev.object, part: ev.part, point: ev.point, accFire: 0, accSmoke: 0 });
+        this.activate(ev.object, ev.part);
+        this.particles.burst("fire", ev.point, [0, 1, 0], 6, 1);
+        this.sound("ignite", ev.point, 0.7);
+        this.sound("burn_loop", ev.point, 0.5);
+        break;
+      case "extinguish": {
+        const f = this.fires.get(`${ev.object}|${ev.part}`);
+        if (f) {
+          this.fires.delete(`${ev.object}|${ev.part}`);
+          this.particles.burst("steam", f.point, [0, 1, 0], 14, 1.2);
+        }
+        this.activate(ev.object, ev.part);
+        this.sound("extinguish", f?.point ?? this.rootPoint(ev.object), 0.6);
+        break;
+      }
+      case "burnout": {
+        this.fires.delete(`${ev.object}|${ev.part}`);
+        this.particles.burst("ash", ev.point, [0, 1, 0], 16, 1);
+        this.particles.burst("smoke", ev.point, [0, 1, 0], 6, 0.8, { color: SMOKE_TONES.grey });
+        const pv = this.partVis(ev.object, ev.part);
+        if (pv) {
+          const def = this.world.materials.get(pv.material);
+          this.visuals.setChar(pv, 1, def?.visual?.charColor ?? 1709072);
+        }
+        this.activate(ev.object, ev.part);
+        break;
+      }
+      case "melt":
+        this.activate(ev.object, ev.part);
+        if (this.time - (this.throttles.get(`melt:${ev.object}|${ev.part}`) ?? -9) > 1.5) {
+          this.throttles.set(`melt:${ev.object}|${ev.part}`, this.time);
+          this.sound("melt_sizzle", this.rootPoint(ev.object), 0.4);
+        }
+        break;
+      case "drip": {
+        const b = this.bounds.get(ev.object);
+        const pv = b?.parts.get(ev.part);
+        const def = this.world.materials.get(ev.material);
+        const color = (pv && this.partColor(pv, def)) ?? fallbackColor(ev.material, def);
+        let tag = this.homeTags.indexOf(ev.object) + 1;
+        if (tag === 0) tag = this.homeTags.push(ev.object);
+        this.particles.spawn("drips", ev.point, [(this.rng() - 0.5) * 0.1, -0.1, (this.rng() - 0.5) * 0.1], { color, tag });
+        break;
+      }
+      case "leak": {
+        const key = `${ev.object}|${ev.part}`;
+        const same = this.leaks.find((l) => l.object === ev.object && l.part === ev.part && Math.hypot(l.point[0] - ev.point[0], l.point[1] - ev.point[1], l.point[2] - ev.point[2]) < 0.03);
+        if (same) {
+          same.rate = ev.rate;
+          same.direction = ev.direction;
+        } else {
+          if (this.leaks.length >= 24) this.leaks.shift();
+          this.leaks.push({ object: ev.object, part: ev.part, fluid: ev.fluid, point: ev.point, direction: ev.direction, rate: ev.rate, pressurized: ev.pressurized, acc: 0 });
+        }
+        void key;
+        break;
+      }
+      case "explode":
+        this.onExplode(ev);
+        break;
+      case "destroyed":
+        break;
+    }
+  }
+  rootPoint(objectId) {
+    const b = this.bounds.get(objectId);
+    return b ? [b.root.position.x, b.root.position.y, b.root.position.z] : [0, 0, 0];
+  }
+  sound(key, point, volume) {
+    this.o.onSound?.(key, point, volume);
+  }
+  partVis(objectId, partId) {
+    return this.bounds.get(objectId)?.parts.get(partId) ?? null;
+  }
+  activate(objectId, partId) {
+    this.active.set(`${objectId}|${partId}`, { object: objectId, part: partId });
+  }
+  /** Current colour of the part's first mesh (char included), or null. */
+  partColor(pv, def) {
+    const mv = pv.meshes[0];
+    if (!mv) return null;
+    const mat = materialsOf2(mv.mesh.material)[0];
+    const c = mat?.color;
+    if (c && c.isColor) {
+      const tint = this.visuals.vertexTint(mv);
+      return tint ? c.clone().multiply(tint).getHex() : c.getHex();
+    }
+    return def ? fallbackColor(def.id, def) : null;
+  }
+  debrisOptions(kind, objectId, partId) {
+    const pv = this.partVis(objectId, partId);
+    const def = pv ? this.world.materials.get(pv.material) : void 0;
+    if (kind === "smoke") return { color: SMOKE_TONES[def?.thermal.smoke ?? "grey"] };
+    if (kind === "fibers" || kind === "leaves") {
+      const c = pv ? this.visuals.baseColorHex(pv.meshes[0] ?? {}) : -1;
+      return c >= 0 ? { color: c } : void 0;
+    }
+    if (kind === "dust" || kind === "chips") {
+      const c = pv && pv.meshes[0] ? this.visuals.baseColorHex(pv.meshes[0]) : -1;
+      return c >= 0 && kind === "chips" ? { color: c } : void 0;
+    }
+    return void 0;
+  }
+  /** Mesh of the part closest to a world point. */
+  nearestMesh(pv, p) {
+    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 (d < bd) {
+        bd = d;
+        best = mv;
+      }
+    }
+    return best;
+  }
+  worldDir(b, v) {
+    b.root.updateWorldMatrix(true, false);
+    return new this.THREE.Vector3(v[0], v[1], v[2]).applyQuaternion(b.root.getWorldQuaternion(this.tmpQ)).normalize();
+  }
+  onDent(ev) {
+    const b = this.bounds.get(ev.object);
+    const pv = b?.parts.get(ev.part);
+    if (!b || !pv) return;
+    const def = this.world.materials.get(pv.material);
+    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;
+      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);
+    this.sound(impactKey(def), ev.worldPoint, clamp(0.3 + ev.dent.depth * 12, 0.3, 1));
+  }
+  onHole(ev) {
+    const b = this.bounds.get(ev.object);
+    const pv = b?.parts.get(ev.part);
+    if (!b || !pv) return;
+    const def = this.world.materials.get(pv.material);
+    const n = this.worldDir(b, ev.hole.normal);
+    const draw = (point, normal) => {
+      const wp = new this.THREE.Vector3(point[0], point[1], point[2]);
+      const mv = this.nearestMesh(pv, wp);
+      if (!mv) return;
+      if (def?.visual?.transparent) {
+        const seed = hashNumbers(ev.time, point[0], point[1], point[2]);
+        this.visuals.addCrack(mv, wp, normal, 7, Math.max(0.05, ev.hole.diameter * 5), 15267071, seed);
+      } else {
+        this.visuals.addHole(mv, wp, normal, ev.hole.diameter);
+      }
+    };
+    draw(ev.worldPoint, n);
+    if (ev.hole.through && ev.exitPoint) draw(ev.exitPoint, n.clone().negate());
+    if (def?.tags?.includes("metal")) this.particles.burst("sparks", ev.worldPoint, [n.x, n.y, n.z], 6, 3.5);
+    this.sound(impactKey(def), ev.worldPoint, 0.6);
+  }
+  onCrack(ev) {
+    const b = this.bounds.get(ev.object);
+    const pv = b?.parts.get(ev.part);
+    if (!b || !pv) return;
+    const def = this.world.materials.get(pv.material);
+    const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
+    const mv = this.nearestMesh(pv, wp);
+    if (mv) {
+      const color = def?.visual?.transparent ? 15267071 : 2762532;
+      this.visuals.addCrack(mv, wp, this.worldDir(b, ev.crack.normal), ev.crack.rays, ev.crack.length, color, hashNumbers(ev.time, ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]));
+    }
+    this.sound(impactKey(def), ev.worldPoint, 0.5);
+  }
+  onFracture(ev) {
+    const b = this.bounds.get(ev.object);
+    const pv = b?.parts.get(ev.part);
+    const matId = pv?.material || (ev.fragments[0]?.material ?? "");
+    const def = this.world.materials.get(matId);
+    let color = fallbackColor(matId, def);
+    let opacity = 0.5;
+    const transparent = def?.visual?.transparent === true;
+    if (pv) {
+      const c = this.partColor(pv, def);
+      if (c !== null) color = c;
+      const m = pv.meshes[0] ? materialsOf2(pv.meshes[0].origMaterial)[0] : void 0;
+      if (m && m.transparent) opacity = clamp(m.opacity, 0.2, 0.8);
+      this.visuals.hide(pv, "broken");
+    }
+    const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
+    const step = this.low ? 2 : 1;
+    for (let i = 0; i < ev.fragments.length; i += step) {
+      const fr = ev.fragments[i];
+      const fdef = this.world.materials.get(fr.material);
+      const mat = this.fragments.materialFor(fr.material, fdef === def || !fdef ? color : fallbackColor(fr.material, fdef), transparent || fdef?.visual?.transparent === true, opacity);
+      this.fragments.spawn(fr, mat, ev.object, maxAlive);
+    }
+    const up = [0, 1, 0];
+    const sizeK = clamp(ev.fragments.length / 10, 0.5, 2);
+    switch (ev.style) {
+      case "shatter":
+        this.particles.burst("shards", ev.point, up, 18 * sizeK, 3);
+        break;
+      case "crumble":
+        this.particles.burst("dust", ev.point, up, 16 * sizeK, 1.2, { color: pv ? this.partColor(pv, def) ?? void 0 : void 0 });
+        this.particles.burst("chips", ev.point, up, 6, 3);
+        break;
+      case "splinter":
+        this.particles.burst("splinters", ev.point, up, 14 * sizeK, 3);
+        this.particles.burst("dust", ev.point, up, 5, 0.8, { color: 11901556 });
+        break;
+      case "tear":
+        this.particles.burst("fibers", ev.point, up, 12 * sizeK, 1.6, { color });
+        break;
+      case "snap":
+        this.particles.burst("chips", ev.point, up, 8 * sizeK, 3);
+        break;
+      default:
+        this.particles.burst("sparks", ev.point, up, 10, 4);
+    }
+    this.sound(fractureKey(def, ev.style), ev.point, clamp(0.4 + ev.fragments.length * 0.03, 0.4, 1));
+  }
+  onDetach(ev) {
+    this.sound("detach", this.rootPoint(ev.object), 0.5);
+    if (!this.autoSplit) return;
+    const b = this.bounds.get(ev.object);
+    if (!b) return;
+    const st = this.world.state(ev.object);
+    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);
+      } catch {
+        break;
+      }
+      this.adoptSplit(b, newId);
+    }
+    const old = b.piece;
+    if (old) {
+      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.sleeping = false;
+    }
+  }
+  /** The renderer side of `splitGroup`: a new group holding the meshes of the new object, made a piece. */
+  adoptSplit(from, newId) {
+    const state = this.world.state(newId);
+    const root = from.root;
+    root.updateWorldMatrix(true, false);
+    const group = new this.THREE.Group();
+    group.name = `destruction-piece-${newId}`;
+    root.getWorldPosition(group.position);
+    root.getWorldQuaternion(group.quaternion);
+    this.scene.add(group);
+    group.updateMatrixWorld(true);
+    const nb = { id: newId, root: group, sync: true, parts: /* @__PURE__ */ new Map(), lastPos: null, lastQuat: null, piece: null, isSplit: true };
+    for (const p of state?.parts ?? []) {
+      const pv = from.parts.get(p.id);
+      if (!pv) continue;
+      from.parts.delete(p.id);
+      nb.parts.set(p.id, pv);
+      for (const mv of pv.meshes) {
+        group.attach(mv.mesh);
+        mv.moved = true;
+      }
+    }
+    this.bounds.set(newId, nb);
+    const meshes = this.meshesOf(nb);
+    if (meshes.length === 0) return;
+    const { half, center } = this.measure(group, meshes);
+    let vel = [0, 0, 0];
+    let ang = [0, 0, 0];
+    const op = from.piece;
+    if (op) {
+      vel = [...op.velocity];
+      ang = [...op.angularVelocity];
+      const c = this.pieceSys.centerOf(op, new this.THREE.Vector3());
+      const nc = center.clone().applyQuaternion(group.quaternion).add(group.position);
+      vel[0] += ang[1] * (nc.z - c.z) - ang[2] * (nc.y - c.y);
+      vel[1] += ang[2] * (nc.x - c.x) - ang[0] * (nc.z - c.z);
+      vel[2] += ang[0] * (nc.y - c.y) - ang[1] * (nc.x - c.x);
+    }
+    const piece = this.pieceSys.create(newId, group, half, center, this.massOf(newId), vel, ang);
+    nb.piece = piece;
+    this.o.onPiece?.(piece);
+  }
+  onExplode(ev) {
+    const p = ev.point;
+    const k = clamp(ev.radius / 3, 0.4, 2.5);
+    this.particles.burst("flash", p, [0, 1, 0], 1, 0, { size: k });
+    this.particles.burst("fire", p, [0, 1, 0], 34 * k, 4 * k, { size: 1 + k * 0.5 });
+    this.particles.burst("smoke", p, [0, 1, 0], 24 * k, 2.2, { color: SMOKE_TONES.black, size: 1 + k * 0.6 });
+    this.particles.burst("dust", p, [0, 1, 0], 22 * k, 3.5 * k);
+    this.particles.burst("sparks", p, [0, 1, 0], 16 * k, 8);
+    this.particles.push(p, ev.radius, 4);
+    if (this.o.explosionLight !== false) {
+      if (!this.light) {
+        this.light = new this.THREE.PointLight(16754784, 0, 10, 2);
+        this.light.name = "destruction-explosion-light";
+      }
+      if (!this.light.parent) this.scene.add(this.light);
+      this.light.position.set(p[0], p[1] + 0.5, p[2]);
+      this.light.distance = Math.max(6, ev.radius * 3);
+      this.lightPeak = clamp(Math.sqrt(Math.max(1, ev.energy)) * 0.6, 10, 400);
+      this.lightDur = 0.35;
+      this.lightT = this.lightDur;
+    }
+    const c = this.v1;
+    for (const pc of this.pieceSys.list) {
+      this.pieceSys.centerOf(pc, c);
+      const dx = c.x - p[0];
+      const dy = c.y - p[1];
+      const dz = c.z - p[2];
+      const d = Math.hypot(dx, dy, dz);
+      if (d > ev.radius) continue;
+      const fall = (1 - d / ev.radius) ** 2;
+      const speed = Math.min(30, Math.sqrt(2 * ev.energy * 0.02 / pc.mass)) * fall;
+      const inv = d > 1e-4 ? 1 / d : 0;
+      const dir = d > 1e-4 ? [dx * inv, dy * inv + 0.3, dz * inv] : [0, 1, 0];
+      const spread = pc.halfExtents[0];
+      this.pieceSys.impulse(pc, [dir[0] * speed * pc.mass, dir[1] * speed * pc.mass, dir[2] * speed * pc.mass], [c.x + (this.rng() - 0.5) * spread, c.y + spread * 0.5, c.z + (this.rng() - 0.5) * spread]);
+    }
+    this.fragments.blast(p, ev.radius, Math.min(20, Math.sqrt(ev.energy) * 0.08));
+    this.sound("explode", p, clamp(0.5 + ev.radius / 10, 0.5, 1));
+  }
+  updateLight(dt) {
+    if (!this.light || this.lightT <= 0) return;
+    this.lightT = Math.max(0, this.lightT - dt);
+    const t = this.lightT / this.lightDur;
+    this.light.intensity = this.lightPeak * t * t;
+  }
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  // Fire, heat, char, melt, leaks
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  updateActive(dt) {
+    this.scanTimer += dt;
+    if (this.scanTimer >= 0.4) {
+      this.scanTimer = 0;
+      for (const b of this.bounds.values()) {
+        for (const pv of b.parts.values()) {
+          if (pv.gone !== "none" && pv.gone !== "broken") continue;
+          const ps = this.world.part(b.id, pv.id);
+          if (!ps) continue;
+          const def = this.world.materials.get(pv.material);
+          if (ps.burning || def?.visual?.glows && ps.temperature > GLOW_FROM_C || Math.abs(ps.char - pv.charApplied) > 0.01 || Math.abs(ps.melt - pv.meltApplied) > 0.01 || pv.gone === "none" && (ps.status === "melted" || ps.status === "ashes")) {
+            this.activate(b.id, pv.id);
+          }
+        }
+      }
+    }
+    for (const [key, a] of this.active) {
+      const pv = this.partVis(a.object, a.part);
+      const ps = pv ? this.world.part(a.object, a.part) : null;
+      if (!pv || !ps) {
+        this.active.delete(key);
+        continue;
+      }
+      const def = this.world.materials.get(pv.material);
+      if (pv.gone === "none") {
+        this.visuals.setChar(pv, ps.char, def?.visual?.charColor ?? 1709072);
+        if (def?.visual?.glows) this.visuals.setGlow(pv, ps.temperature);
+        this.visuals.setMelt(pv, ps.melt);
+        if (ps.status === "melted") this.onGone(a.object, pv, "melted", def);
+        else if (ps.status === "ashes") this.onGone(a.object, pv, "ashes", def);
+      }
+      const fire = this.fires.get(key);
+      if (fire) {
+        if (ps.burning && ps.status !== "broken" && ps.status !== "ashes" && ps.status !== "melted") this.emitFire(fire, pv, def, dt);
+        else this.fires.delete(key);
+      }
+      const hot = def?.visual?.glows === true && ps.temperature > GLOW_FROM_C;
+      if (!ps.burning && !hot && Math.abs(ps.char - pv.charApplied) < 0.01 && Math.abs(ps.melt - pv.meltApplied) < 0.01) {
+        if (def?.visual?.glows && pv.gone === "none") this.visuals.setGlow(pv, 0);
+        this.active.delete(key);
+      }
+    }
+  }
+  onGone(objectId, pv, reason, def) {
+    const bb = new this.THREE.Box3();
+    for (const mv of pv.meshes) bb.union(this.box.setFromObject(mv.mesh));
+    this.visuals.hide(pv, reason);
+    if (bb.isEmpty()) return;
+    const c = bb.getCenter(new this.THREE.Vector3());
+    const s = bb.getSize(new this.THREE.Vector3());
+    const footprint = Math.sqrt(Math.max(s.x * s.z, 1e-4));
+    if (reason === "melted") {
+      this.ground.add("puddle", c.x, c.z, clamp(footprint * 0.55, 0.05, 1), this.partColor(pv, def) ?? fallbackColor(pv.material, def), objectId);
+    } else {
+      this.ground.add("ash", c.x, c.z, clamp(footprint * 0.35, 0.04, 0.5), 1907224, objectId);
+      this.particles.burst("ash", [c.x, bb.max.y, c.z], [0, 1, 0], 10, 0.8);
+    }
+  }
+  emitFire(f, pv, def, dt) {
+    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));
+    let cx = f.point[0];
+    let cy = f.point[1];
+    let cz = f.point[2];
+    let sx = 0.2;
+    let sy = 0.2;
+    let sz = 0.2;
+    if (!bb.isEmpty()) {
+      const c = bb.getCenter(this.v1);
+      const s = bb.getSize(this.v2);
+      cx = c.x;
+      cy = bb.min.y;
+      cz = c.z;
+      sx = s.x;
+      sy = s.y;
+      sz = s.z;
+    }
+    const vol = clamp(Math.cbrt(Math.max(sx * sy * sz, 1e-5)), 0.05, 1.5);
+    f.accFire += (18 + 70 * vol) * dt;
+    f.accSmoke += (6 + 24 * vol) * dt;
+    const tone = SMOKE_TONES[def?.thermal.smoke ?? "grey"];
+    const rnd = this.rng;
+    while (f.accFire >= 1) {
+      f.accFire -= 1;
+      this.particles.spawn("fire", [cx + (rnd() - 0.5) * sx, cy + sy * (0.3 + 0.7 * rnd()), cz + (rnd() - 0.5) * sz], [(rnd() - 0.5) * 0.4, 0.5 + rnd() * 0.9, (rnd() - 0.5) * 0.4], { size: 0.6 + vol * 0.8 });
+    }
+    while (f.accSmoke >= 1) {
+      f.accSmoke -= 1;
+      this.particles.spawn("smoke", [cx + (rnd() - 0.5) * sx, cy + sy * (0.8 + 0.4 * rnd()), cz + (rnd() - 0.5) * sz], [(rnd() - 0.5) * 0.3 + 0.1, 0.4 + rnd() * 0.5, (rnd() - 0.5) * 0.3], { color: tone, size: 0.6 + vol });
+    }
+  }
+  updateLeaks(dt) {
+    for (let i = this.leaks.length - 1; i >= 0; i--) {
+      const l = this.leaks[i];
+      const ps = this.world.part(l.object, l.part);
+      if (!ps || ps.liters === void 0 || ps.liters <= 0) {
+        this.leaks.splice(i, 1);
+        continue;
+      }
+      l.acc += clamp(20 + l.rate * 400, 15, 120) * dt;
+      const color = FLUID_COLORS[l.fluid] ?? 11184810;
+      const d = l.direction;
+      const dl = Math.hypot(d[0], d[1], d[2]) || 1;
+      const sp = l.pressurized ? 2.5 + this.rng() * 1.5 : 0.3 + this.rng() * 0.3;
+      while (l.acc >= 1) {
+        l.acc -= 1;
+        const vel = [d[0] / dl * sp + (this.rng() - 0.5) * 0.25, d[1] / dl * sp + (this.rng() - 0.5) * 0.25, d[2] / dl * sp + (this.rng() - 0.5) * 0.25];
+        if (l.fluid === "gas") this.particles.spawn("steam", l.point, vel, { color, size: 0.5, alpha: 0.5 });
+        else this.particles.spawn("drips", l.point, vel, { color, tag: this.rng() < 0.03 ? this.tagOf(l.object) : 0 });
+      }
+    }
+  }
+  tagOf(object) {
+    let tag = this.homeTags.indexOf(object) + 1;
+    if (tag === 0) tag = this.homeTags.push(object);
+    return tag;
+  }
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  // Emit, clear, restore, stats, dispose
+  // ----------------------------------------------------------------------------------------------------------------------------------
+  emit(kind, point, normal, count, speed) {
+    this.particles.burst(kind, point, normal, count, speed ?? DEFAULT_SPEED[kind] ?? 1, kind === "smoke" ? { color: SMOKE_TONES.grey } : void 0);
+  }
+  restore(objectId) {
+    const homes = /* @__PURE__ */ new Set([objectId]);
+    const self = this.bounds.get(objectId);
+    if (self?.isSplit) for (const pv of self.parts.values()) homes.add(pv.home);
+    for (const home of homes) this.restoreHome(home);
+    for (const [key, a] of [...this.active]) if (homes.has(a.object)) this.active.delete(key);
+    for (const [key, f] of [...this.fires]) if (homes.has(f.object)) this.fires.delete(key);
+    for (let i = this.leaks.length - 1; i >= 0; i--) if (homes.has(this.leaks[i].object)) this.leaks.splice(i, 1);
+    for (const home of homes) {
+      this.fragments.removeHome(home);
+      this.ground.removeHome(home);
+    }
+  }
+  restoreHome(home) {
+    const homeBound = this.bounds.get(home);
+    for (const b of [...this.bounds.values()]) {
+      for (const [pid, pv] of [...b.parts]) {
+        if (pv.home !== home) continue;
+        this.visuals.restorePart(pv);
+        if (b !== homeBound && homeBound) {
+          b.parts.delete(pid);
+          homeBound.parts.set(pid, pv);
+        }
+      }
+      if (b.isSplit && b.parts.size === 0) {
+        this.scene.remove(b.root);
+        this.pieceSys.remove(b.id);
+        this.bounds.delete(b.id);
+      }
+    }
+  }
+  clear() {
+    this.queue.length = 0;
+    this.active.clear();
+    this.fires.clear();
+    this.leaks.length = 0;
+    for (const id of [...this.bounds.keys()]) if (this.bounds.has(id)) this.restore(id);
+    for (const b of [...this.bounds.values()]) {
+      if (b.isSplit) {
+        for (const pv of b.parts.values()) this.visuals.restorePart(pv);
+        this.scene.remove(b.root);
+        this.pieceSys.remove(b.id);
+        this.bounds.delete(b.id);
+      }
+    }
+    this.fragments.clear();
+    this.ground.clear();
+    this.particles.clear();
+    if (this.light) {
+      this.light.intensity = 0;
+      this.lightT = 0;
+      this.scene.remove(this.light);
+    }
+  }
+  stats() {
+    return { fragments: this.fragments.count, particles: this.particles.live, pieces: this.pieceSys.list.length, decals: this.visuals.decalCount + this.ground.count };
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.unsubscribe();
+    this.clear();
+    for (const id of [...this.bounds.keys()]) this.unbind(id);
+    this.fragments.dispose();
+    this.ground.dispose();
+    this.particles.dispose();
+    this.visuals.dispose();
+    this.light?.dispose?.();
+    this.light = null;
+    this.disposed = true;
+  }
+};
+export {
+  createDestructionRenderer,
+  heatColor,
+  specFromObject3D
+};
+//# sourceMappingURL=index.js.map