@adatechnology/game-destruction-three 0.3.3 → 0.5.0

package/dist/index.js

@@ -2,6 +2,10 @@ 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/renderer.ts
+import { createVfx, effectForEvent, EVENT_EFFECTS_MAP } from "@adatechnology/game-vfx";
+import { createVfxRenderer } from "@adatechnology/game-vfx-three";
+
 // src/math.ts
 function createRng(seed) {
   let a = seed >>> 0;
@@ -29,9 +33,6 @@ function hashString(s) {
 }
 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;
@@ -57,6 +58,8 @@ var FragmentSystem = class {
     __publicField(this, "v");
     __publicField(this, "w");
     __publicField(this, "rng", createRng(1374496523));
+    __publicField(this, "markGeometry", null);
+    __publicField(this, "markMaterial", null);
     this.box = new THREE.BoxGeometry(1, 1, 1);
     this.q = new THREE.Quaternion();
     this.dq = new THREE.Quaternion();
@@ -103,6 +106,25 @@ var FragmentSystem = class {
     }
     return g;
   }
+  /**
+   * Bullet holes that stay on a fragment (`Fragment.marks`): dark discs that are children of its mesh, so they fall, spin and settle with it. The mesh is
+   * a unit box scaled to the fragment, so each disc is scaled back; exact for a mark on a face, which is where a bullet hole is.
+   */
+  addMarks(mesh, f) {
+    if (!f.marks?.length) return;
+    this.markGeometry ?? (this.markGeometry = new this.THREE.CircleGeometry(1, 10));
+    this.markMaterial ?? (this.markMaterial = new this.THREE.MeshBasicMaterial({ color: 723465, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
+    const sc = mesh.scale;
+    for (const mark of f.marks) {
+      const disc = new this.THREE.Mesh(this.markGeometry, this.markMaterial);
+      const radius = Math.max(4e-3, mark.diameter) * 0.6;
+      const n = this.v.set(mark.normal[0], mark.normal[1], mark.normal[2]).normalize();
+      disc.position.set(mark.point[0] / sc.x + n.x * 2e-3 / sc.x, mark.point[1] / sc.y + n.y * 2e-3 / sc.y, mark.point[2] / sc.z + n.z * 2e-3 / sc.z);
+      disc.quaternion.setFromUnitVectors(this.w.set(0, 0, 1), n);
+      disc.scale.set(radius / sc.x, radius / sc.y, radius / sc.z);
+      mesh.add(disc);
+    }
+  }
   /** 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;
@@ -136,6 +158,8 @@ var FragmentSystem = class {
         alive--;
       }
     }
+    this.addMarks(mesh, f);
+    return mesh;
   }
   /** Add velocity to every fragment within `radius` of a point (blasts). */
   blast(point, radius, speed) {
@@ -259,6 +283,8 @@ var FragmentSystem = class {
   dispose() {
     this.clear();
     this.box.dispose();
+    this.markGeometry?.dispose();
+    this.markMaterial?.dispose();
     for (const g of this.shardGeos) g?.dispose();
     this.shardGeos = [];
     for (const m of this.materials.values()) m.dispose();
@@ -347,345 +373,6 @@ var GroundSpots = class {
   }
 };
 
-// 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, "rgbStart");
-    __publicField(this, "rgbEnd");
-    __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.rgbStart = new Float32Array(n * 3);
-    this.rgbEnd = new Float32Array(n * 3);
-    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.rgbStart.set(hexToRgb(o?.color ?? def.c0), i * 3);
-    this.rgbEnd.set(hexToRgb(o?.color ?? def.c1), i * 3);
-    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);
-      this.col[i3] = lerp(this.rgbStart[i3], this.rgbEnd[i3], t);
-      this.col[i3 + 1] = lerp(this.rgbStart[i3 + 1], this.rgbEnd[i3 + 1], t);
-      this.col[i3 + 2] = lerp(this.rgbStart[i3 + 2], this.rgbEnd[i3 + 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;
@@ -1010,6 +697,78 @@ var PieceSystem = class {
   }
 };
 
+// src/rebar.ts
+var RebarCages = class {
+  constructor(THREE, scene, radius = 4e-3) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "scene", scene);
+    __publicField(this, "cages", /* @__PURE__ */ new Map());
+    __publicField(this, "geometry");
+    __publicField(this, "material");
+    __publicField(this, "up");
+    __publicField(this, "dir");
+    __publicField(this, "mid");
+    __publicField(this, "q");
+    __publicField(this, "scale");
+    __publicField(this, "m");
+    this.geometry = new THREE.CylinderGeometry(radius, radius, 1, 6);
+    this.material = new THREE.MeshStandardMaterial({ color: 7628380, roughness: 0.55, metalness: 0.6 });
+    this.up = new THREE.Vector3(0, 1, 0);
+    this.dir = new THREE.Vector3();
+    this.mid = new THREE.Vector3();
+    this.q = new THREE.Quaternion();
+    this.scale = new THREE.Vector3();
+    this.m = new THREE.Matrix4();
+  }
+  /** Bars drawn now, over every part. */
+  get count() {
+    let n = 0;
+    for (const mesh of this.cages.values()) n += mesh.count;
+    return n;
+  }
+  /** Meshes of the live cages (tests and picking). */
+  meshes() {
+    return [...this.cages.values()];
+  }
+  /** Draw `bars` (world space) as the cage of `key`; an empty list removes it. */
+  set(key, bars) {
+    this.remove(key);
+    if (bars.length === 0) return;
+    const mesh = new this.THREE.InstancedMesh(this.geometry, this.material, bars.length);
+    bars.forEach(([a, b], i) => {
+      this.dir.set(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+      const length = this.dir.length();
+      this.mid.set((a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2);
+      this.q.setFromUnitVectors(this.up, length > 1e-9 ? this.dir.divideScalar(length) : this.up);
+      this.m.compose(this.mid, this.q, this.scale.set(1, Math.max(length, 1e-4), 1));
+      mesh.setMatrixAt(i, this.m);
+    });
+    mesh.instanceMatrix.needsUpdate = true;
+    mesh.castShadow = true;
+    this.scene.add(mesh);
+    this.cages.set(key, mesh);
+  }
+  remove(key) {
+    const mesh = this.cages.get(key);
+    if (!mesh) return;
+    this.scene.remove(mesh);
+    mesh.dispose();
+    this.cages.delete(key);
+  }
+  /** Remove the cages of every part of `object` (keys are `object|part`). */
+  removeObject(object) {
+    for (const key of [...this.cages.keys()]) if (key.startsWith(`${object}|`)) this.remove(key);
+  }
+  clear() {
+    for (const key of [...this.cages.keys()]) this.remove(key);
+  }
+  dispose() {
+    this.clear();
+    this.geometry.dispose();
+    this.material.dispose();
+  }
+};
+
 // src/spec.ts
 import { guessMaterial, inferJoints } from "@adatechnology/game-destruction";
 function partHintOf(value) {
@@ -1214,6 +973,7 @@ var DecalKit = class {
     __publicField(this, "disc", null);
     __publicField(this, "discMat", null);
     __publicField(this, "lineMats", /* @__PURE__ */ new Map());
+    __publicField(this, "patchMats", /* @__PURE__ */ new Map());
   }
   discGeometry() {
     return this.disc ?? (this.disc = new this.THREE.CircleGeometry(1, 14));
@@ -1229,6 +989,15 @@ var DecalKit = class {
       polygonOffsetUnits: -4
     }));
   }
+  /** Opaque patch in the colour of what shows under a spalled coat. */
+  patchMaterial(color) {
+    let m = this.patchMats.get(color);
+    if (!m) {
+      m = new this.THREE.MeshBasicMaterial({ color, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -3, polygonOffsetUnits: -3 });
+      this.patchMats.set(color, m);
+    }
+    return m;
+  }
   lineMaterial(color) {
     let m = this.lineMats.get(color);
     if (!m) {
@@ -1241,6 +1010,8 @@ var DecalKit = class {
     this.disc?.dispose();
     this.discMat?.dispose();
     for (const m of this.lineMats.values()) m.dispose();
+    for (const m of this.patchMats.values()) m.dispose();
+    this.patchMats.clear();
     this.disc = null;
     this.discMat = null;
     this.lineMats.clear();
@@ -1532,6 +1303,16 @@ var Visuals = class {
     disc.renderOrder = 2;
     this.addDecal(mv, { obj: disc });
   }
+  /** A patch where a surface coat came off, in the colour of the core under it; drawn under the bullet holes. */
+  addSpall(mv, worldPoint, worldNormal, radius, color) {
+    const { s, pos, quat } = this.decalPose(mv.mesh, worldPoint, worldNormal, 15e-4);
+    const disc = new this.THREE.Mesh(this.kit.discGeometry(), this.kit.patchMaterial(color));
+    disc.position.copy(pos);
+    disc.quaternion.copy(quat);
+    disc.scale.setScalar(Math.max(0.01, radius) / s);
+    disc.renderOrder = 1;
+    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);
@@ -1972,8 +1753,13 @@ var Visuals = class {
 };
 
 // src/renderer.ts
+var rendererCount = 0;
+var IMPACT_TAGS = ["metal", "glass", "wood"];
 var GLOW_FROM_C = 430;
 var QUEUE_CAP = 4e3;
+var FIRE_CEILING_SECONDS = 3600;
+var GENERIC_REFERENCE_RADIUS = 15;
+var PRIMED_FIRE_RADIUS = 0.2;
 var FLUID_COLORS = {
   water: 9226495,
   fuel: 14262322,
@@ -2053,20 +1839,22 @@ var Renderer = class {
     __publicField(this, "queue", []);
     __publicField(this, "unsubscribe");
     __publicField(this, "visuals");
-    __publicField(this, "particles");
     __publicField(this, "fragments");
     __publicField(this, "ground");
     __publicField(this, "pieceSys");
+    __publicField(this, "cages");
     __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, "vfx");
+    /** Names this renderer to the world's drips, so a shared world tells each renderer where its own landed. */
+    __publicField(this, "owner", `destruction-${++rendererCount}`);
+    __publicField(this, "stopLanding");
+    /** The effects renderer made here when the host gave no shared world; it is stepped in `update`. */
+    __publicField(this, "ownVfx");
     __publicField(this, "time", 0);
     __publicField(this, "scanTimer", 0);
     __publicField(this, "disposed", false);
@@ -2089,17 +1877,11 @@ var Renderer = class {
     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.vfx = o.vfx ?? createVfx({ profile: this.quality, gravity: this.gravity, groundAt: this.groundAt, sprites: { capacity: maxParticles, density: this.low ? 0.6 : 1 } });
+    this.ownVfx = o.vfx ? void 0 : createVfxRenderer(THREE, { scene: o.scene, camera: o.camera ?? new THREE.PerspectiveCamera(), vfx: this.vfx, pointScale: o.pointScale ?? 700 });
+    this.stopLanding = this.vfx.onLand(this.owner, (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,
@@ -2108,6 +1890,7 @@ var Renderer = class {
       max: this.maxFragments,
       life: o.fragmentLife ?? 12
     });
+    this.cages = new RebarCages(THREE, o.scene);
     this.pieceSys = new PieceSystem(THREE, {
       groundAt: this.groundAt,
       gravity: this.gravity,
@@ -2315,8 +2098,7 @@ var Renderer = class {
     this.pieceSys.update(dt);
     this.fragments.update(dt);
     this.ground.update(dt);
-    this.updateLight(dt);
-    this.particles.update(dt);
+    this.ownVfx?.update(dt);
     this.syncTransforms();
   }
   drainQueue() {
@@ -2370,12 +2152,12 @@ var Renderer = class {
         break;
       case "ricochet": {
         const d = ev.direction;
-        this.particles.burst("sparks", ev.point, d, 4 + Math.min(10, ev.energy / 150), 4);
+        this.vfx.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));
+        this.vfx.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);
@@ -2385,6 +2167,7 @@ var Renderer = class {
         break;
       case "collapse":
         this.splitLoose(ev.object);
+        this.playEvent({ kind: "collapse" }, this.rootPoint(ev.object));
         break;
       case "disassemble_progress": {
         const k = `unscrew:${ev.joint}`;
@@ -2395,34 +2178,45 @@ var Renderer = class {
         break;
       }
       case "ignite":
-        this.fires.set(`${ev.object}|${ev.part}`, { object: ev.object, part: ev.part, point: ev.point, accFire: 0, accSmoke: 0 });
+        this.startFire(ev);
         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 "primed":
         if (ev.trigger !== "explosion") {
-          this.fires.set(`${ev.object}|${ev.part}`, { object: ev.object, part: ev.part, point: ev.point, accFire: 0, accSmoke: 0 });
+          this.vfx.fire({ point: ev.point, radius: PRIMED_FIRE_RADIUS, life: ev.delay });
           this.activate(ev.object, ev.part);
-          this.particles.burst("fire", ev.point, [0, 1, 0], 6, 1);
           this.sound("ignite", ev.point, 0.7);
         }
         break;
+      case "spall":
+        this.onSpall(ev);
+        break;
+      case "stage":
+        this.onStage(ev);
+        break;
+      case "expose":
+        this.cages.set(`${ev.object}|${ev.part}`, ev.bars);
+        if (ev.bars.length > 0) {
+          const [a, b] = ev.bars[0];
+          this.playEvent({ kind: "expose" }, [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2]);
+        }
+        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.stopFire(`${ev.object}|${ev.part}`);
+          this.vfx.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 });
+        this.stopFire(`${ev.object}|${ev.part}`);
+        this.vfx.burst("ash", ev.point, [0, 1, 0], 16, 1);
+        this.vfx.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);
@@ -2445,7 +2239,7 @@ var Renderer = class {
         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 });
+        this.vfx.spawn("drips", ev.point, [(this.rng() - 0.5) * 0.1, -0.1, (this.rng() - 0.5) * 0.1], { color, tag, owner: this.owner });
         break;
       }
       case "leak": {
@@ -2536,7 +2330,7 @@ var Renderer = class {
       if (!this.visuals.shown(mv)) continue;
       this.visuals.applyDent(mv, wp, wn, ev.dent);
     }
-    if (def?.tags?.includes("metal")) this.particles.burst("sparks", ev.worldPoint, [wn.x, wn.y, wn.z], 4 + Math.min(8, ev.dent.depth * 150), 3.2);
+    if (def?.tags?.includes("metal")) this.vfx.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) {
@@ -2558,7 +2352,7 @@ var Renderer = class {
     };
     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);
+    if (def?.tags?.includes("metal")) this.vfx.burst("sparks", ev.worldPoint, [n.x, n.y, n.z], 6, 3.5);
     this.sound(impactKey(def), ev.worldPoint, 0.6);
   }
   onCrack(ev) {
@@ -2574,6 +2368,59 @@ var Renderer = class {
     }
     this.sound(impactKey(def), ev.worldPoint, 0.5);
   }
+  /** Outward normal of the face of `mv` nearest to a world point: the thin axis of its world box (right for a wall; a sloped face is left to the vertex-range binding). */
+  faceNormal(mv, point) {
+    const box = this.visuals.worldBox(mv, this.box);
+    const size = box.getSize(this.v1);
+    const axis = size.x <= size.y && size.x <= size.z ? "x" : size.y <= size.z ? "y" : "z";
+    const side = point[axis] >= (box.min[axis] + box.max[axis]) / 2 ? 1 : -1;
+    return new this.THREE.Vector3(axis === "x" ? side : 0, axis === "y" ? side : 0, axis === "z" ? side : 0);
+  }
+  /** The material an impact effect is chosen by: the tags of the material (`metal`, `glass`, `wood`), else stone and the like are `concrete`. */
+  impactMaterial(def) {
+    for (const tag of IMPACT_TAGS) if (def?.tags?.includes(tag)) return tag;
+    return "concrete";
+  }
+  /**
+   * Plays the effect the event map names for a destruction event (`data/event-effects.json` of `game-vfx`, or `RendererOptions.eventEffects`) at a point.
+   * Answers whether one played, so the caller can leave out the burst it replaces.
+   */
+  playEvent(event, point) {
+    const id = effectForEvent(event, this.o.eventEffects ?? EVENT_EFFECTS_MAP);
+    if (!id) return false;
+    return this.vfx.play(id, point, { seed: hashNumbers(point[0], point[1], point[2], this.time) }) !== null;
+  }
+  /** A coat came off: a patch in the colour of the core under it, below the bullet holes and cracks. */
+  onSpall(ev) {
+    const pv = this.partVis(ev.object, ev.part);
+    if (!pv) return;
+    const wp = new this.THREE.Vector3(ev.point[0], ev.point[1], ev.point[2]);
+    const mv = this.nearestMesh(pv, wp);
+    if (!mv) return;
+    const def = this.world.materials.get(pv.material);
+    this.playEvent({ kind: "spall", material: this.impactMaterial(def) }, ev.point);
+    this.visuals.addSpall(mv, wp, this.faceNormal(mv, wp), Math.sqrt(ev.area / Math.PI), fallbackColor(pv.material, def));
+  }
+  /**
+   * Stage 2 of a staged part: the unit-sized fragments come out and the part stays drawn (hiding it is what `fracture` does). The opening itself
+   * (cutting the wall's faces) is not drawn yet: it needs the per-vertex binding of the house renderer.
+   */
+  onStage(ev) {
+    const played = this.playEvent({ kind: "stage", stage: ev.stage }, ev.opening?.center ?? this.rootPoint(ev.object));
+    if (!ev.fragments || !ev.opening) return;
+    const pv = this.partVis(ev.object, ev.part);
+    const def = pv ? this.world.materials.get(pv.material) : void 0;
+    const color = (pv ? this.partColor(pv, def) : null) ?? fallbackColor(pv?.material ?? "", def);
+    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);
+      this.fragments.spawn(fr, this.fragments.materialFor(fr.material, fdef === def || !fdef ? color : fallbackColor(fr.material, fdef), false), ev.object, maxAlive);
+    }
+    if (!played) this.vfx.burst("dust", ev.opening.center, [0, 1, 0], 14, 1.2, { color });
+    this.sound(impactKey(def), ev.opening.center, 0.8);
+  }
   onFracture(ev) {
     const b = this.bounds.get(ev.object);
     const pv = b?.parts.get(ev.part);
@@ -2601,24 +2448,24 @@ var Renderer = class {
     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);
+        this.vfx.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);
+        this.vfx.burst("dust", ev.point, up, 16 * sizeK, 1.2, { color: pv ? this.partColor(pv, def) ?? void 0 : void 0 });
+        this.vfx.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 });
+        this.vfx.burst("splinters", ev.point, up, 14 * sizeK, 3);
+        this.vfx.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 });
+        this.vfx.burst("fibers", ev.point, up, 12 * sizeK, 1.6, { color });
         break;
       case "snap":
-        this.particles.burst("chips", ev.point, up, 8 * sizeK, 3);
+        this.vfx.burst("chips", ev.point, up, 8 * sizeK, 3);
         break;
       default:
-        this.particles.burst("sparks", ev.point, up, 10, 4);
+        this.vfx.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));
   }
@@ -2697,27 +2544,10 @@ var Renderer = class {
     nb.piece = piece;
     this.o.onPiece?.(piece);
   }
-  onExplode(ev) {
+  onExplode(ev, options = {}) {
     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;
-    }
+    if (options.visual !== false) this.playExplosion(ev, options);
+    this.vfx.push(p, ev.radius, 4);
     const c = this.v1;
     for (const pc of this.pieceSys.list) {
       this.pieceSys.centerOf(pc, c);
@@ -2736,11 +2566,23 @@ var Renderer = class {
     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;
+  playExplosion(ev, options) {
+    const named = options.effect ?? ev.effect;
+    const direction = options.direction;
+    const scale = clamp(ev.radius / GENERIC_REFERENCE_RADIUS, 0.2, 3);
+    if (named !== void 0 && this.vfx.explosion(named, ev.point, direction ? { direction } : {}) !== null) return;
+    this.vfx.explosion("generic", ev.point, { scale, ...direction ? { direction } : {} });
+  }
+  startFire(ev) {
+    const key = `${ev.object}|${ev.part}`;
+    this.stopFire(key);
+    this.fires.set(key, { object: ev.object, part: ev.part, point: ev.point, follow: { x: ev.point[0], y: ev.point[1], z: ev.point[2] } });
+  }
+  stopFire(key) {
+    const fire = this.fires.get(key);
+    if (!fire) return;
+    if (fire.handle !== void 0) this.vfx.stop(fire.handle);
+    this.fires.delete(key);
   }
   // ----------------------------------------------------------------------------------------------------------------------------------
   // Fire, heat, char, melt, leaks
@@ -2778,8 +2620,8 @@ var Renderer = class {
       }
       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);
+        if (ps.burning && ps.status !== "broken" && ps.status !== "ashes" && ps.status !== "melted") this.emitFire(fire, pv, def);
+        else this.stopFire(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) {
@@ -2800,43 +2642,25 @@ var Renderer = class {
       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);
+      this.vfx.burst("ash", [c.x, bb.max.y, c.z], [0, 1, 0], 10, 0.8);
     }
   }
-  emitFire(f, pv, def, dt) {
+  emitFire(f, pv, def) {
     const bb = this.box;
     bb.makeEmpty();
     const tmp = new this.THREE.Box3();
     for (const mv of pv.meshes) if (this.visuals.shown(mv)) bb.union(this.visuals.worldBox(mv, tmp));
-    let cx = f.point[0];
-    let cy = f.point[1];
-    let cz = f.point[2];
-    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 });
+      f.follow.x = c.x;
+      f.follow.y = bb.min.y;
+      f.follow.z = c.z;
     }
+    if (f.handle !== void 0) return;
+    const size = bb.isEmpty() ? this.v2.set(0.2, 0.2, 0.2) : bb.getSize(this.v2);
+    const radius = clamp(Math.max(size.x, size.z) * 0.5, 0.12, 1.2);
+    const smokeColor = SMOKE_TONES[def?.thermal.smoke ?? "grey"];
+    f.handle = this.vfx.fire({ point: [f.follow.x, f.follow.y, f.follow.z], radius, life: FIRE_CEILING_SECONDS, follow: f.follow, ...smokeColor !== void 0 ? { smokeColor } : {} });
   }
   updateLeaks(dt) {
     for (let i = this.leaks.length - 1; i >= 0; i--) {
@@ -2854,8 +2678,8 @@ var Renderer = class {
       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 });
+        if (l.fluid === "gas") this.vfx.spawn("steam", l.point, vel, { color, size: 0.5, alpha: 0.5 });
+        else this.vfx.spawn("drips", l.point, vel, { color, tag: this.rng() < 0.03 ? this.tagOf(l.object) : 0, owner: this.owner });
       }
     }
   }
@@ -2868,10 +2692,10 @@ var Renderer = class {
   // 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);
+    this.vfx.burst(kind, point, normal, count, speed ?? DEFAULT_SPEED[kind] ?? 1, kind === "smoke" ? { color: SMOKE_TONES.grey } : void 0);
   }
-  explode(point, energy, radius) {
-    this.onExplode({ type: "explode", object: "", part: "", time: this.time, point, energy, radius });
+  explode(point, energy, radius, options) {
+    this.onExplode({ type: "explode", object: "", part: "", time: this.time, point, energy, radius }, options);
   }
   restore(objectId) {
     const homes = /* @__PURE__ */ new Set([objectId]);
@@ -2879,11 +2703,12 @@ var Renderer = class {
     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 (const [key, f] of [...this.fires]) if (homes.has(f.object)) this.stopFire(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);
+      this.cages.removeObject(home);
     }
   }
   restoreHome(home) {
@@ -2907,7 +2732,7 @@ var Renderer = class {
   clear() {
     this.queue.length = 0;
     this.active.clear();
-    this.fires.clear();
+    for (const key of [...this.fires.keys()]) this.stopFire(key);
     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()]) {
@@ -2920,15 +2745,20 @@ var Renderer = class {
     }
     this.fragments.clear();
     this.ground.clear();
-    this.particles.clear();
-    if (this.light) {
-      this.light.intensity = 0;
-      this.lightT = 0;
-      this.scene.remove(this.light);
-    }
+    this.cages.clear();
+    this.vfx.sprites().clear();
+    this.ownVfx?.world.clear();
   }
   stats() {
-    return { fragments: this.fragments.count, particles: this.particles.live, pieces: this.pieceSys.list.length, decals: this.visuals.decalCount + this.ground.count };
+    return { fragments: this.fragments.count, particles: this.vfx.sprites().live + this.ownedVfxParticles(), pieces: this.pieceSys.list.length, decals: this.visuals.decalCount + this.ground.count };
+  }
+  ownedVfxParticles() {
+    if (!this.ownVfx) return 0;
+    const { puffs, sparks, glows, chunks } = this.vfx.stats();
+    return puffs + sparks + glows + chunks;
+  }
+  rebarCount() {
+    return this.cages.count;
   }
   dispose() {
     if (this.disposed) return;
@@ -2937,10 +2767,10 @@ var Renderer = class {
     for (const id of [...this.bounds.keys()]) this.unbind(id);
     this.fragments.dispose();
     this.ground.dispose();
-    this.particles.dispose();
+    this.cages.dispose();
+    this.stopLanding();
     this.visuals.dispose();
-    this.light?.dispose?.();
-    this.light = null;
+    this.ownVfx?.dispose();
     this.disposed = true;
   }
 };