@adatechnology/game-vehicles 0.5.0 → 0.6.0

package/dist/index.js

@@ -892,7 +892,7 @@ function advance(geo, ti, deadline) {
   }
   return ti.builtBlocks === total;
 }
-function start(geo) {
+function start(geo, store = cache) {
   const pos = geo.attributes.position;
   const triangles = trianglesOf(geo);
   const ti = {
@@ -905,7 +905,7 @@ function start(geo) {
     blocks: new Float64Array(blockCount(triangles) * 6),
     builtBlocks: 0
   };
-  cache.set(geo, ti);
+  store.set(geo, ti);
   return ti;
 }
 function triIndexOf(geo) {
@@ -957,6 +957,106 @@ function boundsFromIndex(geo) {
     }
   return { box, version: ti.positionVersion };
 }
+var rayCache = /* @__PURE__ */ new WeakMap();
+function rayIndexOf(geo) {
+  const shared = cache.get(geo);
+  if (shared && isCurrent(geo, shared) && shared.builtBlocks === blockCount(shared.triangles)) return shared;
+  let ti = rayCache.get(geo);
+  if (!ti || !isCurrent(geo, ti)) ti = start(geo, rayCache);
+  advance(geo, ti, Infinity);
+  return ti;
+}
+var BLOCK_SLACK = 1e-6;
+var scratch = /* @__PURE__ */ new WeakMap();
+function scratchOf(THREE) {
+  let s = scratch.get(THREE);
+  if (!s) {
+    s = {
+      inverse: new THREE.Matrix4(),
+      local: new THREE.Ray(),
+      box: new THREE.Box3(),
+      a: new THREE.Vector3(),
+      b: new THREE.Vector3(),
+      c: new THREE.Vector3(),
+      point: new THREE.Vector3(),
+      world: new THREE.Vector3(),
+      sphere: new THREE.Sphere()
+    };
+    scratch.set(THREE, s);
+  }
+  return s;
+}
+function indexable(THREE, mesh) {
+  const geo = mesh.geometry;
+  if (mesh.raycast !== THREE.Mesh.prototype.raycast) return false;
+  if (!mesh.isMesh || mesh.isSkinnedMesh || mesh.isInstancedMesh || mesh.isBatchedMesh || !geo || !geo.isBufferGeometry) return false;
+  if (!mesh.material || Array.isArray(mesh.material)) return false;
+  if (geo.morphAttributes && geo.morphAttributes.position && geo.morphAttributes.position.length) return false;
+  return supports(geo);
+}
+function raycastMesh(THREE, raycaster, mesh, out) {
+  const geo = mesh.geometry;
+  const s = scratchOf(THREE);
+  if (geo.boundingSphere === null) geo.computeBoundingSphere();
+  s.sphere.copy(geo.boundingSphere).applyMatrix4(mesh.matrixWorld);
+  if (!raycaster.ray.intersectsSphere(s.sphere)) return;
+  const ti = rayIndexOf(geo);
+  if (!ti) return;
+  s.inverse.copy(mesh.matrixWorld).invert();
+  s.local.copy(raycaster.ray).applyMatrix4(s.inverse);
+  const material = mesh.material;
+  const back = material.side === THREE.BackSide;
+  const cull = material.side === THREE.FrontSide;
+  const P = geo.attributes.position;
+  const ix = geo.index;
+  const count = ix ? ix.count : P.count;
+  const first = Math.max(0, geo.drawRange.start);
+  const last = Math.min(count, geo.drawRange.start + geo.drawRange.count);
+  const t0 = Math.ceil(first / 3);
+  const t1 = Math.floor(last / 3);
+  const B = ti.boxes;
+  const K = ti.blocks;
+  for (let blk = Math.floor(t0 / TRI_BLOCK); blk * TRI_BLOCK < t1; blk++) {
+    const o = blk * 6;
+    s.box.min.set(K[o] - BLOCK_SLACK, K[o + 1] - BLOCK_SLACK, K[o + 2] - BLOCK_SLACK);
+    s.box.max.set(K[o + 3] + BLOCK_SLACK, K[o + 4] + BLOCK_SLACK, K[o + 5] + BLOCK_SLACK);
+    if (!s.local.intersectsBox(s.box)) continue;
+    const end = Math.min(t1, (blk + 1) * TRI_BLOCK);
+    for (let t = Math.max(t0, blk * TRI_BLOCK); t < end; t++) {
+      const j = t * 6;
+      s.box.min.set(B[j] - BLOCK_SLACK, B[j + 1] - BLOCK_SLACK, B[j + 2] - BLOCK_SLACK);
+      s.box.max.set(B[j + 3] + BLOCK_SLACK, B[j + 4] + BLOCK_SLACK, B[j + 5] + BLOCK_SLACK);
+      if (!s.local.intersectsBox(s.box)) continue;
+      const a = ix ? ix.getX(t * 3) : t * 3;
+      const b = ix ? ix.getX(t * 3 + 1) : t * 3 + 1;
+      const c = ix ? ix.getX(t * 3 + 2) : t * 3 + 2;
+      s.a.fromBufferAttribute(P, a);
+      s.b.fromBufferAttribute(P, b);
+      s.c.fromBufferAttribute(P, c);
+      const hit = back ? s.local.intersectTriangle(s.c, s.b, s.a, true, s.point) : s.local.intersectTriangle(s.a, s.b, s.c, cull, s.point);
+      if (hit === null) continue;
+      s.world.copy(s.point).applyMatrix4(mesh.matrixWorld);
+      const distance = raycaster.ray.origin.distanceTo(s.world);
+      if (distance < raycaster.near || distance > raycaster.far) continue;
+      const normal = new THREE.Vector3();
+      THREE.Triangle.getNormal(s.a, s.b, s.c, normal);
+      out.push({ distance, point: s.world.clone(), object: mesh, face: { a, b, c, normal, materialIndex: 0 }, faceIndex: Math.floor(t) });
+    }
+  }
+}
+function collect(THREE, raycaster, object, recursive, out) {
+  if (object.layers.test(raycaster.layers)) {
+    if (indexable(THREE, object)) raycastMesh(THREE, raycaster, object, out);
+    else object.raycast(raycaster, out);
+  }
+  if (recursive) for (const child of object.children) collect(THREE, raycaster, child, true, out);
+}
+function raycastIndexed(THREE, raycaster, objects, recursive = false) {
+  const out = [];
+  for (const object of objects) collect(THREE, raycaster, object, recursive, out);
+  out.sort((x, y) => x.distance - y.distance);
+  return out;
+}
 
 // src/geometry.ts
 function installGeometry(kit) {
@@ -2290,6 +2390,7 @@ function installBody(kit) {
   }
   kit.profX = profX;
   const _sr = new THREE.Raycaster();
+  _sr.layers.enableAll();
   kit.surfaceAt = function(c, org, dir, o) {
     o = o || {};
     c.root.updateMatrixWorld(true);
@@ -2306,7 +2407,7 @@ function installBody(kit) {
     _sr.set(p0.clone().applyMatrix4(Mw), d.clone().transformDirection(Mw));
     _sr.near = 0;
     _sr.far = o.max || 20;
-    const h = _sr.intersectObjects(cands, false)[0];
+    const h = raycastIndexed(THREE, _sr, cands)[0];
     if (!h) return null;
     const n = h.face ? h.face.normal.clone().transformDirection(h.object.matrixWorld).transformDirection(inv) : d.clone().negate();
     if (n.dot(d) > 0) n.negate();
@@ -2328,6 +2429,7 @@ function installGlass(kit) {
   const V3 = THREE.Vector3;
   const I = kit._;
   const { MATERIALS, crease, cutGeometry, pathShape, subdivide, tumble, uvProject } = I;
+  I.paneSeals = /* @__PURE__ */ new WeakMap();
   kit.addGlass = function(c, geo, label, type, o) {
     o = o || {};
     if (!geo.attributes.uv || o.reuv) o.aspect = uvProject(geo, o.uvAxes);
@@ -2394,7 +2496,7 @@ function installGlass(kit) {
         cy /= poly.length;
         const base = I.resolveLabel(label ? label(i, polys.length) : { key: "window" });
         const lab = { key: base.key, label: kit.t("parts.glass_side", { label: base.label, s }) };
-        kit.addGlass(c, geo, lab, o.type || "tempered", {
+        const pane = kit.addGlass(c, geo, lab, o.type || "tempered", {
           mat: o.mat || (o.see === false ? MATERIALS.glassDark : MATERIALS.glass),
           pos: new V3(cx, cy, s * I.halfAt(Wg, T, cy)),
           outline: shp.getSpacedPoints(56),
@@ -2410,6 +2512,7 @@ function installGlass(kit) {
         pts.pop();
         const seal = c.tube(pts, 0.011, MATERIALS.trim, { closed: true, seg: 72, rs: 5 });
         seal.castShadow = false;
+        I.paneSeals.set(pane, seal);
       });
     });
   };
@@ -4119,6 +4222,47 @@ function installWheels(kit) {
   Object.assign(I, {});
 }
 
+// src/particles.ts
+import { warnOnce } from "@adatechnology/game-contracts";
+
+// src/routed-particles.ts
+var ROUTED_PARTICLE_TYPES = { smoke: "particle_puff", dust: "particle_puff", fire: "particle_glow" };
+var PUFF_LOOKS = {
+  smokewhite: [10133927, 0.42],
+  smokeblack: [1776412, 0.62],
+  smokegray: [5593436, 0.5],
+  smokesteam: [11975873, 0.3],
+  dust: [7235160, 0.34],
+  fire: [16777215, 0.9]
+};
+var LIFE = { dust: 1.6, smoke: 2.8, fire: 0.7 };
+var FIRE_COLOR = 16753968;
+var SMOKE_START_SCALE = 0.18;
+function routedParticleRequest(input) {
+  const { type } = input;
+  const look = PUFF_LOOKS[type + (input.variant ?? "")] ?? PUFF_LOOKS[type] ?? PUFF_LOOKS.smokewhite;
+  const life = input.life ?? LIFE[type] ?? 99;
+  const size = (input.size ?? 1) * (input.grow ?? 1);
+  const isFire = type === "fire";
+  const growth = isFire ? 1 : (SMOKE_START_SCALE + 1.5 * (1 - Math.exp(-life * 1.1)) + life * 0.12) / SMOKE_START_SCALE;
+  return {
+    effect: ROUTED_PARTICLE_TYPES[type],
+    point: input.position,
+    values: {
+      vx: input.velocity[0],
+      vy: input.velocity[1],
+      vz: input.velocity[2],
+      life,
+      size: isFire ? size * 0.85 : size * SMOKE_START_SCALE,
+      grow: growth,
+      color: input.color ?? (isFire ? FIRE_COLOR : look[0]),
+      alpha: input.alpha ?? look[1],
+      gravity: isFire ? 0 : type === "dust" ? 0 : -0.08,
+      drag: type === "dust" ? 2.5 : isFire ? 1.5 : 0.9
+    }
+  };
+}
+
 // src/particles.ts
 function installParticles(kit) {
   const THREE = kit.THREE;
@@ -4210,7 +4354,7 @@ function installParticles(kit) {
       });
     }
     const list = fire ? FIRE_TEXTURES : SMOKE_TEXTURES;
-    const mat = new THREE.SpriteMaterial({
+    const build = () => new THREE.SpriteMaterial({
       map: list[Math.floor(Math.random() * list.length)],
       color: new THREE.Color(col),
       transparent: true,
@@ -4218,6 +4362,7 @@ function installParticles(kit) {
       opacity: op,
       blending: fire ? THREE.AdditiveBlending : THREE.NormalBlending
     });
+    const mat = kit.particleMaterials ? kit.particleMaterials.own(build) : build();
     const dis = { value: 0 };
     mat.userData.dis = dis;
     mat.onBeforeCompile = function(sh) {
@@ -4245,11 +4390,37 @@ function installParticles(kit) {
   function killParticle(c, i) {
     const P = c.particles[i];
     c.effects.remove(P.m);
-    if (P.own) P.m.material.dispose();
+    if (P.own) {
+      if (kit.particleMaterials) kit.particleMaterials.release(P.m.material);
+      else P.m.material.dispose();
+    }
     c.particles.splice(i, 1);
   }
+  function routeParticle(c, effects, type, pos, vel, o) {
+    c.effects.updateWorldMatrix(true, false);
+    const at = pos.clone().applyMatrix4(c.effects.matrixWorld);
+    const to = vel.clone().transformDirection(c.effects.matrixWorld).multiplyScalar(vel.length());
+    const colour = o.col == null ? void 0 : new THREE.Color(o.col).getHex();
+    effects.play(
+      routedParticleRequest({
+        type,
+        position: [at.x, at.y, at.z],
+        velocity: [to.x, to.y, to.z],
+        ...o.variant ? { variant: o.variant } : {},
+        ...colour !== void 0 ? { color: colour } : {},
+        ...o.op != null ? { alpha: o.op } : {},
+        ...o.s ? { size: o.s } : {},
+        ...o.life ? { life: o.life } : {},
+        ...o.grow ? { grow: o.grow } : {}
+      })
+    );
+    return null;
+  }
   kit.spawn = function(c, type, pos, vel, o) {
     o = o || {};
+    const effects = ROUTED_PARTICLE_TYPES[type] ? kit.effects?.() : void 0;
+    if (effects) return routeParticle(c, effects, type, pos, vel, o);
+    if (ROUTED_PARTICLE_TYPES[type] && !kit.effects) warnOnce("game-vehicles.own-particles", "game-vehicles drew its smoke, fire and dust with sprites of its own because the host lent no effects world (options.effects); pass the host effects so the puffs share one budget");
     if (c.particles.length >= PARTICLE_LIMIT) {
       const idx = c.particles.findIndex(function(q) {
         return TRANSIENT_TYPES[q.type];
@@ -4521,6 +4692,7 @@ function installFluids(kit) {
   };
   kit.defineFluid("stain", { fresh: "#4a4a44", dry: "#26241f", wipeable: false });
   const _fr = new THREE.Raycaster();
+  _fr.layers.enableAll();
   kit.splat = function(c, p, n, r, o) {
     o = o || {};
     n = n.clone().normalize();
@@ -4962,31 +5134,55 @@ function installFluids(kit) {
 }
 
 // src/glass-damage.ts
+function crackedGlassMaterial(THREE, texture) {
+  return new THREE.MeshStandardMaterial({
+    color: 16777215,
+    map: texture,
+    emissive: 6976118,
+    emissiveMap: texture,
+    transparent: true,
+    roughness: 0.25,
+    metalness: 0.1,
+    side: THREE.DoubleSide,
+    depthWrite: false
+  });
+}
 function installGlassDamage(kit) {
   const THREE = kit.THREE;
   const V3 = THREE.Vector3;
   const PI = Math.PI;
   const I = kit._;
   const document2 = kit.document;
-  const { DOUBLE_SIDE, MATERIALS, crease, cutGeometry, mergeGeometries, subdivide, tumble } = I;
-  function glassUV(msh, pLocal) {
+  const { MATERIALS, crease, cutGeometry, mergeGeometries, subdivide, tumble } = I;
+  function glassUV(c, msh, pLocal) {
     const pos = msh.geometry.attributes.position;
     const uv = msh.geometry.attributes.uv;
     if (!uv) return [0.5, 0.5];
-    const inv = new THREE.Matrix4().copy(msh.matrix).invert();
-    const q = pLocal.clone().applyMatrix4(inv);
-    let best = 1e9;
-    let bi = 0;
-    const v = new V3();
-    for (let i = 0; i < pos.count; i++) {
-      v.fromBufferAttribute(pos, i);
-      const d = v.distanceToSquared(q);
-      if (d < best) {
-        best = d;
-        bi = i;
-      }
+    c.root.updateMatrixWorld(true);
+    const q = msh.worldToLocal(c.vehicle.localToWorld(pLocal.clone()));
+    const idx = msh.geometry.index;
+    const tri = new THREE.Triangle();
+    const near = new V3();
+    const bary = new V3();
+    let best = Infinity;
+    const out = [0.5, 0.5];
+    const count = idx ? idx.count : pos.count;
+    for (let f = 0; f + 2 < count; f += 3) {
+      const ia = idx ? idx.getX(f) : f;
+      const ib = idx ? idx.getX(f + 1) : f + 1;
+      const ic = idx ? idx.getX(f + 2) : f + 2;
+      tri.a.fromBufferAttribute(pos, ia);
+      tri.b.fromBufferAttribute(pos, ib);
+      tri.c.fromBufferAttribute(pos, ic);
+      tri.closestPointToPoint(q, near);
+      const d = near.distanceToSquared(q);
+      if (d >= best) continue;
+      best = d;
+      tri.getBarycoord(near, bary);
+      out[0] = uv.getX(ia) * bary.x + uv.getX(ib) * bary.y + uv.getX(ic) * bary.z;
+      out[1] = uv.getY(ia) * bary.x + uv.getY(ib) * bary.y + uv.getY(ic) * bary.z;
     }
-    return [uv.getX(bi), uv.getY(bi)];
+    return out;
   }
   function drawWeb(x, cx, cy, s, ax, rnd) {
     const n = 16 + Math.floor(rnd() * 8);
@@ -5063,19 +5259,9 @@ function installGlassDamage(kit) {
       x0.fillStyle = "rgba(48,66,72,0.5)";
       x0.fillRect(0, 0, 256, 256);
       G.tex = new THREE.CanvasTexture(G.cv);
-      msh.material = new THREE.MeshStandardMaterial({
-        color: 16777215,
-        map: G.tex,
-        emissive: 6976118,
-        emissiveMap: G.tex,
-        transparent: true,
-        roughness: 0.25,
-        metalness: 0.1,
-        side: DOUBLE_SIDE,
-        depthWrite: false
-      });
+      msh.material = crackedGlassMaterial(THREE, G.tex);
     }
-    const uv = glassUV(msh, p);
+    const uv = glassUV(c, msh, p);
     const x = G.cv.getContext("2d");
     drawWeb(x, uv[0] * 256, (1 - uv[1]) * 256, sc != null ? sc : 0.6 + force * 0.5, Math.max(0.4, G.aspect || 1), c.rand);
     G.tex.needsUpdate = true;
@@ -5220,6 +5406,13 @@ function installGlassDamage(kit) {
     }
     const seatGeo = [];
     const d = dir.clone().normalize();
+    if (msh.parent && msh.parent !== c.vehicle) {
+      c.root.updateMatrixWorld(true);
+      const toVehicle = new THREE.Matrix4().copy(c.vehicle.matrixWorld).invert().multiply(msh.parent.matrixWorld);
+      cubesAt.forEach(function(q) {
+        q.applyMatrix4(toVehicle);
+      });
+    }
     cubesAt.forEach(function(p, i) {
       if (i % 3 === 0 && c.seatTops.length && !c.rollState && !c.flipped) {
         let best = null;
@@ -5422,6 +5615,7 @@ function installImpact(kit) {
     polygonOffsetUnits: -2
   });
   const _ray = new THREE.Raycaster();
+  _ray.layers.enableAll();
   function findSurface(c, p, dir) {
     c.root.updateMatrixWorld(true);
     const Mw = c.vehicle.matrixWorld;
@@ -5503,6 +5697,7 @@ function installImpact(kit) {
     const v0 = new V3();
     const w = new V3();
     const sc = new V3();
+    const local = new V3();
     const cab = m.cabin && !c.flipped && !c.rollState ? m.cabin : null;
     c.deform.forEach(function(msh) {
       if (!msh.parent || !msh.visible) return;
@@ -5517,7 +5712,15 @@ function installImpact(kit) {
       irel.copy(rel).invert();
       if (!g.userData.p0) g.userData.p0 = new Float32Array(pos.array);
       const p0 = g.userData.p0;
+      local.copy(p).applyMatrix4(irel);
+      const reach = H.R / Math.max(1e-6, Math.min(sc.x, sc.y, sc.z));
+      const reach2 = reach * reach;
+      const arr = pos.array;
       for (let i = 0; i < pos.count; i++) {
+        const dx = arr[3 * i] - local.x;
+        const dy = arr[3 * i + 1] - local.y;
+        const dz = arr[3 * i + 2] - local.z;
+        if (dx * dx + dy * dy + dz * dz >= reach2) continue;
         v.fromBufferAttribute(pos, i).applyMatrix4(rel);
         const a = dentField(v, H);
         if (a <= 0) continue;
@@ -5533,10 +5736,15 @@ function installImpact(kit) {
       }
       if (changed) {
         pos.needsUpdate = true;
-        if (g.userData.crease) crease(g, 42);
+        if (g.userData.crease && c.smoothLater) c.smoothLater(msh);
+        else if (g.userData.crease) crease(g, 42);
         else g.computeVertexNormals();
-        g.computeBoundingSphere();
         g.computeBoundingBox();
+        const sphere = g.boundingSphere ?? (g.boundingSphere = new THREE.Sphere());
+        g.boundingBox.getCenter(sphere.center);
+        let far2 = 0;
+        for (let i = 0; i < pos.count; i++) far2 = Math.max(far2, sphere.center.distanceToSquared(v.fromBufferAttribute(pos, i)));
+        sphere.radius = Math.sqrt(far2);
       }
     });
     const dset = new Set(c.deform);
@@ -5620,13 +5828,14 @@ function installImpact(kit) {
   kit.impact = impact;
   kit.partEffects = {};
   const _pr = new THREE.Raycaster();
+  _pr.layers.enableAll();
   function probe(c, o, d, far) {
     c.root.updateMatrixWorld(true);
     const Mw = c.vehicle.matrixWorld;
     const inv = new THREE.Matrix4().copy(Mw).invert();
     _pr.set(o.clone().applyMatrix4(Mw), d.clone().transformDirection(Mw));
     _pr.far = far || 10;
-    const hits = _pr.intersectObject(c.vehicle, true);
+    const hits = raycastIndexed(THREE, _pr, [c.vehicle], true);
     for (let i = 0; i < hits.length; i++) {
       const h = hits[i];
       const ob = h.object;
@@ -6992,6 +7201,7 @@ function installZoneDecals(kit) {
     return hole;
   }
   const _zr = new THREE.Raycaster();
+  _zr.layers.enableAll();
   const PROXY_MIN_TRIANGLES = 500;
   const STROKE_REACH = 0.6;
   const _pv = new V3();
@@ -7226,6 +7436,7 @@ function installZoneDecals(kit) {
     return out;
   }
   const _rt = new THREE.Raycaster();
+  _rt.layers.enableAll();
   function scratchPath(c, s, len, ang, cands, B) {
     const n = s.n.clone().normalize();
     const t = Math.abs(n.y) < 0.9 ? new V3().crossVectors(new V3(0, 1, 0), n) : new V3().crossVectors(new V3(1, 0, 0), n);
@@ -10507,6 +10718,8 @@ function createVehicleKit(options) {
     V3: THREE.Vector3,
     PI: Math.PI,
     document: doc,
+    particleMaterials: opts.particleMaterials,
+    effects: opts.effects,
     strings,
     t,
     matchers: createMatchers(strings),
@@ -10762,7 +10975,9 @@ function createVehicleKit(options) {
     assignDeep(strings, resolveStrings(opts.locale));
     return kit;
   };
-  const { THREE: _three, lod: _lod, locale: _locale, document: _document, plugins, ...config } = opts;
+  const { THREE: _three, lod: _lod, locale: _locale, document: _document, particleMaterials: _particleMaterials, effects: _effects, plugins, ...config } = opts;
+  void _particleMaterials;
+  void _effects;
   void _three;
   void _lod;
   void _locale;
@@ -10861,6 +11076,14 @@ var floorPan = (b) => ({
   center: [b.center[0], b.center[1] - b.size[1] / 2 + Math.min(0.14, b.size[1]) / 2 + 0.04, b.center[2]],
   size: [b.size[0] * 0.5, Math.min(0.14, b.size[1]), b.size[2] * 0.95]
 });
+function paneBox(c, pane, inverse) {
+  pane.geometry.computeBoundingBox();
+  const box = pane.geometry.boundingBox.clone().applyMatrix4(pane.matrixWorld);
+  box.applyMatrix4(inverse);
+  const center = [(box.min.x + box.max.x) / 2, (box.min.y + box.max.y) / 2, (box.min.z + box.max.z) / 2];
+  const size = [box.max.x - box.min.x, box.max.y - box.min.y, box.max.z - box.min.z];
+  return { center, size };
+}
 function buildVehicleModel(kit, c, options = {}) {
   const kind = kindOf(c);
   const m = c.meta;
@@ -11001,6 +11224,16 @@ function buildVehicleModel(kit, c, options = {}) {
       tags: [role, ...tags]
     });
   }
+  const claimed = new Set(zones.filter((z) => roleOfZone(z) === "glass").flatMap((z) => z.glass ?? []));
+  c.root.updateMatrixWorld(true);
+  const inverse = c.vehicle.matrixWorld.clone().invert();
+  for (const pane of c.glass ?? []) {
+    if (claimed.has(pane)) continue;
+    const G = pane.userData.glass;
+    const bb = paneBox(c, pane, inverse);
+    const laminated = G?.type === "laminated" || m.bullet;
+    add({ id: `pane_${G?.key ?? "glass"}`, role: "glass", name: String(G?.label ?? G?.key ?? "glass"), material: "glass", box: bb, mass: 10 * areaOf(bb.size), hp: laminated ? 4e3 : 450, panes: [pane], visual: false, tags: ["glass"] });
+  }
   if (!hubZone) {
     const h = Math.max(0.15, belt - clearance);
     add({
@@ -11336,6 +11569,76 @@ function buildVehicleModel(kit, c, options = {}) {
 }
 
 // src/destructible/visual.ts
+var HOLE_DECAL_SCALE = 2.4;
+var DOOR_DEPTH = 0.07;
+var DOOR_EDGE_PIECES = 16;
+var DOOR_CARD_COLOR = "#3b3e42";
+var DOOR_LINER_COLOR = "#5a5e64";
+var DOOR_LINER_DARK = 0.15;
+var DOOR_STRIP_THIN = 0.05;
+var DOOR_STRIP_NEAR = 0.04;
+var DOOR_STRIP_OVER = 0.3;
+var DOOR_TOP_OVER_PANE = 0.03;
+var DOOR_STRIP_SUB = 0.02;
+var HOLE_TEXTURE_SIZE = 64;
+var DOOR_HANDLE_INSET = 0.12;
+var DOOR_HANDLE_MIN = 0.07;
+var DOOR_HANDLE_MAX = 0.24;
+var DOOR_HANDLE_THIN = 0.07;
+var DOOR_HANDLE_OUTSIDE = 0.1;
+var PANE_SEAT_OUT = 0.05;
+var PANE_SEAT_IN = -0.05;
+var PANE_SEAT_REACH = 0.14;
+var PANE_SEAT_SAMPLES = 24;
+var PANE_SEAT_LIFT = 4e-3;
+var PANE_FRAME_NEAR = 0.07;
+var DRAWN_MIRROR_SIZE = 0.3;
+var DRAWN_MIRROR_REACH = 0.4;
+var DRAWN_MIRROR_MOUNT = 0.2;
+var MIRROR_GLASS_FIT = 0.76;
+var MIRROR_GLASS_THIN = 0.04;
+var MIRROR_GLASS_MIN = 0.05;
+var MIRROR_GLASS_COLOR = "#59636a";
+var HOLE_RIM = { steel: "#b7bcc0", aluminium: "#d3d6d8", plastic: "#d9d6cc", rubber: "#141414", glass: "#eef3f5" };
+var holeMaterials = /* @__PURE__ */ new WeakMap();
+var holeDisc = null;
+function holeDiscGeometry(THREE) {
+  holeDisc = holeDisc ?? new THREE.CircleGeometry(1, 12);
+  return holeDisc;
+}
+function holeMaterial(kit, material) {
+  const key = kit;
+  const cache2 = holeMaterials.get(key) ?? /* @__PURE__ */ new Map();
+  holeMaterials.set(key, cache2);
+  const known = cache2.get(material);
+  if (known) return known;
+  const I = kit._;
+  const THREE = kit.THREE;
+  const canvas = kit.document?.createElement?.("canvas");
+  const x = canvas?.getContext?.("2d");
+  let made = I.MATERIALS.dark;
+  if (x) {
+    canvas.width = canvas.height = HOLE_TEXTURE_SIZE;
+    const mid = HOLE_TEXTURE_SIZE / 2;
+    x.fillStyle = HOLE_RIM[material] ?? HOLE_RIM.steel;
+    x.beginPath();
+    for (let i = 0; i < 18; i++) {
+      const a = i / 18 * Math.PI * 2;
+      const r = mid * (i % 2 ? 0.98 : 0.76);
+      x.lineTo(mid + Math.cos(a) * r, mid + Math.sin(a) * r);
+    }
+    x.closePath();
+    x.fill();
+    x.fillStyle = "#050505";
+    x.beginPath();
+    x.arc(mid, mid, mid * 0.42, 0, Math.PI * 2);
+    x.fill();
+    const map = new THREE.CanvasTexture(canvas);
+    made = new THREE.MeshStandardMaterial({ map, transparent: true, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -2, roughness: 0.55, metalness: material === "steel" || material === "aluminium" ? 0.6 : 0 });
+  }
+  cache2.set(material, made);
+  return made;
+}
 var VehicleVisuals = class {
   constructor(kit, c, model) {
     __publicField(this, "kit");
@@ -11353,14 +11656,23 @@ var VehicleVisuals = class {
     __publicField(this, "syncPlates", /* @__PURE__ */ new Map());
     /** Doors and lids whose own skin was cut from the body and hung on the hinge (true), or that had none to take and keep the plate (false). */
     __publicField(this, "skins", /* @__PURE__ */ new Map());
+    /** How high each door's cut reaches. */
+    __publicField(this, "doorTops", /* @__PURE__ */ new Map());
     __publicField(this, "lightsOn", true);
     /** Heavy body meshes whose triangle index is still to build (null once done). */
     __publicField(this, "warming");
     /** A panel was torn off since the last `pump`: that frame already paid for the cut, the smoothing starts on the next one. */
     __publicField(this, "tornThisFrame", false);
+    /** A shared crease queue owns the smoothing: `pump` only closes the frame of the cut. */
+    __publicField(this, "queued", false);
+    /** A panel was torn and the queue has not asked yet: the first `pendingUnits(frame)` after it holds the work for that frame. */
+    __publicField(this, "holdArmed", false);
+    __publicField(this, "holdFrame", -1);
     /** Normal smoothing still running, by mesh: a mesh cut again gets a new task and the old one is dropped. */
     __publicField(this, "smoothing", /* @__PURE__ */ new Map());
     __publicField(this, "hood");
+    ;
+    c.smoothLater = (mesh) => this.smoothLater(mesh);
     this.kit = kit;
     this.c = c;
     this.model = model;
@@ -11369,6 +11681,8 @@ var VehicleVisuals = class {
     for (const p of model.parts) this.byId.set(p.id, p);
     c.root.updateMatrixWorld(true);
     this.hood = this.nameHood();
+    this.seatPanes();
+    this.seatDoorHandles();
     this.warming = c.deform.filter((msh) => msh.geometry && msh.geometry.attributes.position && msh.geometry.attributes.position.count >= 1500);
     if (!this.warming.length) this.warming = null;
     for (const p of model.parts) {
@@ -11389,6 +11703,7 @@ var VehicleVisuals = class {
     const id = z ? z.id : this.model.parts.find((p) => p.role === "hood")?.id;
     if (!id) return null;
     c.hood.piv.name = id;
+    c.hood.piv.userData.plateOf = id;
     return { id, open: c.hood.open, sign: c.hood.sign || 1 };
   }
   mirrorObjects(p) {
@@ -11476,6 +11791,7 @@ var VehicleVisuals = class {
       recess.userData.noFollow = true;
       const piv = new THREE.Group();
       piv.name = p.id;
+      piv.userData.plateOf = p.id;
       piv.position.set(hx, cy, sk + s * 0.016);
       piv.userData.rigid = true;
       this.c.vehicle.add(piv);
@@ -11492,6 +11808,7 @@ var VehicleVisuals = class {
       recess.userData.noFollow = true;
       const piv = new THREE.Group();
       piv.name = p.id;
+      piv.userData.plateOf = p.id;
       piv.position.set(sk - 0.016, B.y1 - 0.05, 0);
       piv.userData.rigid = true;
       this.c.vehicle.add(piv);
@@ -11555,10 +11872,19 @@ var VehicleVisuals = class {
     try {
       if (p.role === "door") {
         const dirty = /* @__PURE__ */ new Set();
-        const rect = [B.x0 + 0.03, B.x1 - 0.03, B.y0 + Math.min(0.08, (B.y1 - B.y0) * 0.1), B.y1 - 0.02];
-        const pcs = I.cutPanel(this.c, z, rect, true, dirty).map((x) => x.mesh).filter((m) => !!m);
+        const glassBox = new this.THREE.Box3();
+        for (const g of I.windowsOver(this.c, z, inv)) glassBox.union(I.localBox(this.c, g, inv));
+        const top = glassBox.isEmpty() ? B.y1 - 0.02 : Math.max(B.y1 - 0.02, glassBox.min.y + DOOR_TOP_OVER_PANE);
+        this.doorTops.set(id, top);
+        const rect = [B.x0 + 0.03, B.x1 - 0.03, B.y0 + Math.min(0.08, (B.y1 - B.y0) * 0.1), top];
+        const pcs = I.cutPanel(this.c, z, rect, true, dirty, { anyN: true }).map((x) => x.mesh).filter((m) => !!m);
         this.mend(dirty);
-        if (pcs.length) objs = [...pcs, ...I.followersIn(this.c, z, inv), ...I.windowsOver(this.c, z, inv)];
+        if (pcs.length) {
+          const panes = I.windowsOver(this.c, z, inv);
+          const seals = panes.map((g) => I.paneSeals.get(g)).filter((s) => !!s);
+          const mirrors = this.mirrorsOn(z);
+          objs = [...pcs, ...this.doorCards(pcs, z), ...I.followersIn(this.c, z, inv), ...panes, ...seals, ...mirrors];
+        }
       } else {
         const pcs = this.cutZone(z);
         if (pcs.length) objs = [...pcs, ...I.followersIn(this.c, z, inv)];
@@ -11576,10 +11902,124 @@ var VehicleVisuals = class {
       const di = deform.indexOf(o);
       if (di >= 0) deform.splice(di, 1);
     }
+    if (p.role === "door" && objs.length > 0) {
+      this.doorEdges(piv, z, this.doorTops.get(id) ?? B.y1 - 0.02);
+      this.liftDoorTrim(objs, z);
+      this.cutStripsAcross(piv, z, inv);
+    }
     piv.quaternion.copy(q);
     this.c.root.updateMatrixWorld(true);
     return objs.length > 0;
   }
+  /** A door has edges: a band that follows the skin all round closes it to its card and hides where the cut followed the triangles of the shell; the same band, in the same paint as on a real car, lines the opening. */
+  doorEdges(piv, z, y1) {
+    const THREE = this.THREE;
+    const B = z.box;
+    const side2 = z.side < 0 ? -1 : 1;
+    const flat = piv.position.z - side2 * 0.016;
+    const x0 = B.x0 + 0.03;
+    const x1 = B.x1 - 0.03;
+    const y0 = B.y0 + Math.min(0.08, (B.y1 - B.y0) * 0.1);
+    const loop = [];
+    const run = (ax, ay, bx, by) => {
+      for (let i = 0; i < DOOR_EDGE_PIECES; i++) loop.push([ax + (bx - ax) * i / DOOR_EDGE_PIECES, ay + (by - ay) * i / DOOR_EDGE_PIECES]);
+    };
+    run(x0, y0, x1, y0);
+    run(x1, y0, x1, y1);
+    run(x1, y1, x0, y1);
+    run(x0, y1, x0, y0);
+    const heights = loop.map(([x, y]) => this.surface("z", side2, B, [[x, y]]) ?? flat);
+    const band = (lift) => {
+      const position = [];
+      const index = [];
+      loop.forEach(([x, y], i) => {
+        position.push(x, y, heights[i] + side2 * lift, x, y, heights[i] + side2 * (lift - DOOR_DEPTH));
+        const a = i * 2;
+        const b = (i + 1) % loop.length * 2;
+        index.push(a, a + 1, b, b, a + 1, b + 1);
+      });
+      const g = new THREE.BufferGeometry();
+      g.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
+      g.setIndex(index);
+      g.computeVertexNormals();
+      return g;
+    };
+    const paint = this.paint().clone();
+    paint.side = THREE.DoubleSide;
+    const edges = new THREE.Mesh(band(2e-3), paint);
+    const lining = new THREE.Mesh(band(2e-3), paint);
+    for (const m of [edges, lining]) {
+      m.userData.noFollow = true;
+      m.castShadow = false;
+      this.c.vehicle.add(m);
+    }
+    piv.attach(edges);
+  }
+  /** A front door carries the mirror drawn at its corner. */
+  mirrorsOn(z) {
+    if (!z.mirror) return [];
+    const own = (z.mirrors ?? []).filter((o) => o.parent);
+    if (own.length) return own;
+    const part = this.model.parts.find((q) => q.role === "mirror" && Math.sign(q.box.center[2]) === Math.sign(z.side));
+    return part ? (this.extra.get(part.id) ?? []).filter((o) => o.parent) : [];
+  }
+  /** The panel drawn inside the door is lit like the rest of a cabin, not a black slab from end to end. */
+  liftDoorTrim(objs, z) {
+    const card = this.I.makeMaterial(DOOR_LINER_COLOR, { roughness: 0.85 });
+    const inv = this.I.worldInverseOf(this.c);
+    for (const o of objs) {
+      if (!o.isMesh || o.userData.glass) continue;
+      const box = this.I.localBox(this.c, o, inv);
+      const size = box.getSize(new this.THREE.Vector3());
+      if (size.x > (z.box.x1 - z.box.x0) * 0.4 && size.y > (z.box.y1 - z.box.y0) * 0.3 && size.z < DOOR_DEPTH * 1.5 && o.material?.color?.getHSL({ h: 0, s: 0, l: 0 }).l < DOOR_LINER_DARK) o.material = card;
+    }
+  }
+  /** A long strip drawn along the side of the car (the chrome of the belt): the part over the door goes with the door, and nothing stays across the opening. */
+  cutStripsAcross(piv, z, inv) {
+    const THREE = this.THREE;
+    const B = z.box;
+    const x0 = B.x0 + 0.03;
+    const x1 = B.x1 - 0.03;
+    const y0 = B.y0 - DOOR_STRIP_NEAR;
+    const y1 = B.y1 + DOOR_STRIP_NEAR;
+    const deform = this.c.deform ?? [];
+    for (const o of [...this.c.vehicle.children]) {
+      if (!o.isMesh || o === piv || deform.includes(o) || o.userData.glass || o.userData.decal || !o.visible) continue;
+      const box = this.I.localBox(this.c, o, inv);
+      const size = box.getSize(new THREE.Vector3());
+      const mid = box.getCenter(new THREE.Vector3());
+      if (Math.sign(mid.z) !== Math.sign(z.side) || size.z > DOOR_STRIP_THIN || size.y > DOOR_STRIP_THIN || Math.min(box.max.x, x1) - Math.max(box.min.x, x0) < (x1 - x0) * DOOR_STRIP_OVER || mid.y < y0 || mid.y > y1) continue;
+      const toVehicle = new THREE.Matrix4().multiplyMatrices(inv, o.matrixWorld);
+      const v = new THREE.Vector3();
+      const sdf = (x, y, zz) => {
+        v.set(x, y, zz).applyMatrix4(toVehicle);
+        return Math.max(x0 - v.x, v.x - x1);
+      };
+      this.kit.cutMesh(o, [{ sdf }], 42, { sub: DOOR_STRIP_SUB });
+      const from = Math.max(box.min.x, x0);
+      const to = Math.min(box.max.x, x1);
+      const piece = this.box(to - from, size.y, size.z, o.material, (from + to) / 2, mid.y, mid.z);
+      piece.userData.noFollow = true;
+      piv.attach(piece);
+    }
+  }
+  /** The inside of a door: its skin brought in by the depth of the door, in the trim's dark plastic, so the open door is a door and not one sheet of paint. */
+  doorCards(skins, z) {
+    const cardMaterial = this.I.makeMaterial(DOOR_CARD_COLOR, { roughness: 0.8 });
+    return skins.map((skin) => {
+      const card = new this.THREE.Mesh(skin.geometry, cardMaterial);
+      card.position.copy(skin.position);
+      card.quaternion.copy(skin.quaternion);
+      card.scale.copy(skin.scale);
+      const side2 = z.side < 0 ? -1 : 1;
+      const inward = -side2 * DOOR_DEPTH;
+      card.position.z += inward;
+      card.userData.noFollow = true;
+      card.castShadow = false;
+      this.c.vehicle.add(card);
+      return card;
+    });
+  }
   mend(dirty) {
     dirty.forEach((msh) => {
       const g = msh.geometry;
@@ -11589,7 +12029,191 @@ var VehicleVisuals = class {
       g.computeBoundingBox();
     });
   }
+  /**
+   * A windshield or rear window is drawn as a flat quad, and the body under its edge is curved: the pane and its frame stand off the shell or rise past the roof. Each one
+   * comes to the shell along its own normal, by how far the shell is just outside each of its vertices.
+   */
+  seatPanes() {
+    const THREE = this.THREE;
+    const c = this.c;
+    c.root.updateMatrixWorld(true);
+    const shell = c.deform.filter((o) => o.isMesh && !o.userData.glass && c.paints?.has(o.material));
+    if (!shell.length) return;
+    const ray = new THREE.Raycaster();
+    ray.layers.enableAll();
+    for (const pane of c.glass) {
+      if (pane.userData.glass?.outline) continue;
+      const seat = this.paneSeat(pane, shell, ray);
+      if (!seat) continue;
+      const near = c.vehicle.children.filter((o) => o.isMesh && o !== pane && !o.userData.glass && !shell.includes(o) && this.onPane(o, pane, seat));
+      for (const m of [pane, ...near]) this.movePane(m, seat);
+      const past = this.shellPast(pane, shell, ray, seat.normal);
+      if (past > 0) for (const m of [pane, ...near]) this.movePane(m, { normal: seat.normal, samples: [{ at: seat.samples[0].at, by: past }] });
+    }
+  }
+  /** The outward normal of a pane and how far the shell is at each sampled point (world). */
+  paneSeat(pane, shell, ray) {
+    const THREE = this.THREE;
+    const pos = pane.geometry.attributes.position;
+    const box = new THREE.Box3().setFromObject(pane);
+    const centre = box.getCenter(new THREE.Vector3());
+    const vehicleCentre = new THREE.Box3().setFromObject(this.c.root).getCenter(new THREE.Vector3());
+    const tri = new THREE.Triangle();
+    const normal = new THREE.Vector3();
+    let largest = 0;
+    const idx = pane.geometry.index;
+    const count = idx ? idx.count : pos.count;
+    for (let f = 0; f + 2 < count; f += 3) {
+      tri.a.fromBufferAttribute(pos, idx ? idx.getX(f) : f);
+      tri.b.fromBufferAttribute(pos, idx ? idx.getX(f + 1) : f + 1);
+      tri.c.fromBufferAttribute(pos, idx ? idx.getX(f + 2) : f + 2);
+      if (tri.getArea() > largest) {
+        largest = tri.getArea();
+        tri.getNormal(normal);
+      }
+    }
+    normal.transformDirection(pane.matrixWorld);
+    if (normal.dot(centre.clone().sub(vehicleCentre)) < 0) normal.negate();
+    const samples = [];
+    const seen = /* @__PURE__ */ new Set();
+    const v = new THREE.Vector3();
+    const step = Math.max(1, Math.floor(pos.count / PANE_SEAT_SAMPLES));
+    for (let i = 0; i < pos.count; i += step) {
+      v.fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld);
+      const key = `${Math.round(v.x * 100)},${Math.round(v.y * 100)},${Math.round(v.z * 100)}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const away = v.clone().sub(centre);
+      away.addScaledVector(normal, -away.dot(normal)).normalize();
+      let by = -Infinity;
+      for (const off of [PANE_SEAT_OUT, PANE_SEAT_IN, PANE_SEAT_IN * 3]) {
+        const at = v.clone().addScaledVector(away, off);
+        ray.set(at.addScaledVector(normal, PANE_SEAT_REACH), normal.clone().negate());
+        ray.far = PANE_SEAT_REACH * 2;
+        const hit = raycastIndexed(THREE, ray, shell)[0];
+        if (hit) by = Math.max(by, PANE_SEAT_REACH - hit.distance);
+      }
+      if (by > -Infinity) samples.push({ at: v.clone(), by });
+    }
+    return samples.length >= 3 ? { normal, samples } : null;
+  }
+  /** How far the shell still stands past a seated pane, over its triangles. */
+  shellPast(pane, shell, ray, normal) {
+    const THREE = this.THREE;
+    const pos = pane.geometry.attributes.position;
+    const idx = pane.geometry.index;
+    const count = idx ? idx.count : pos.count;
+    const tri = new THREE.Triangle();
+    const step = Math.max(1, Math.floor(count / 3 / PANE_SEAT_SAMPLES)) * 3;
+    let past = 0;
+    for (let f = 0; f + 2 < count; f += step) {
+      tri.a.fromBufferAttribute(pos, idx ? idx.getX(f) : f);
+      tri.b.fromBufferAttribute(pos, idx ? idx.getX(f + 1) : f + 1);
+      tri.c.fromBufferAttribute(pos, idx ? idx.getX(f + 2) : f + 2);
+      const mid = tri.getMidpoint(new THREE.Vector3()).applyMatrix4(pane.matrixWorld);
+      ray.set(mid.addScaledVector(normal, PANE_SEAT_REACH), normal.clone().negate());
+      ray.far = PANE_SEAT_REACH;
+      const hit = raycastIndexed(THREE, ray, shell)[0];
+      if (hit) past = Math.max(past, PANE_SEAT_REACH - hit.distance + PANE_SEAT_LIFT);
+    }
+    return past;
+  }
+  /** A frame or a seal drawn on the pane: small, and close to its plane. */
+  onPane(o, pane, seat) {
+    const THREE = this.THREE;
+    const box = new THREE.Box3().setFromObject(o);
+    if (box.isEmpty() || !new THREE.Box3().setFromObject(pane).expandByScalar(PANE_FRAME_NEAR).containsBox(box)) return false;
+    const at = box.getCenter(new THREE.Vector3());
+    return Math.abs(at.clone().sub(seat.samples[0].at).dot(seat.normal)) < PANE_SEAT_REACH;
+  }
+  movePane(mesh, seat) {
+    const THREE = this.THREE;
+    const g = mesh.geometry.clone();
+    const pos = g.attributes.position;
+    const inverse = mesh.matrixWorld.clone().invert();
+    const v = new THREE.Vector3();
+    for (let i = 0; i < pos.count; i++) {
+      v.fromBufferAttribute(pos, i).applyMatrix4(mesh.matrixWorld);
+      let weight = 0;
+      let by = 0;
+      for (const s of seat.samples) {
+        const w = 1 / (s.at.distanceToSquared(v) + 1e-4);
+        weight += w;
+        by += s.by * w;
+      }
+      v.addScaledVector(seat.normal, by / weight + PANE_SEAT_LIFT).applyMatrix4(inverse);
+      pos.setXYZ(i, v.x, v.y, v.z);
+    }
+    pos.needsUpdate = true;
+    g.computeBoundingBox();
+    g.computeBoundingSphere();
+    mesh.geometry = g;
+  }
+  /** A handle is at the free edge of its door, the end away from the hinge. */
+  seatDoorHandles() {
+    const THREE = this.THREE;
+    const c = this.c;
+    const inv = this.I.worldInverseOf(c);
+    for (const p of this.model.parts) {
+      if (p.role !== "door") continue;
+      const z = this.zone(p);
+      if (!z) continue;
+      const B = z.box;
+      const free = z.hinge === "rear" ? B.x1 - DOOR_HANDLE_INSET : B.x0 + DOOR_HANDLE_INSET;
+      for (const o of c.vehicle.children) {
+        if (!o.isMesh || o.material !== this.I.MATERIALS.chrome || o.userData.glass) continue;
+        const box = this.I.localBox(c, o, inv);
+        const size = box.getSize(new THREE.Vector3());
+        const at = box.getCenter(new THREE.Vector3());
+        const isHandle = size.x > DOOR_HANDLE_MIN && size.x < DOOR_HANDLE_MAX && size.y < DOOR_HANDLE_THIN && size.z < DOOR_HANDLE_THIN;
+        if (!isHandle || Math.sign(at.z) !== Math.sign(z.side) || at.x < B.x0 || at.x > B.x1 || at.y < B.y0 || at.y > B.y1) continue;
+        const here = this.surface("z", z.side < 0 ? -1 : 1, B, [[at.x, at.y]]);
+        if (here != null && Math.abs(here - at.z) > DOOR_HANDLE_OUTSIDE) continue;
+        const skin = this.surface("z", z.side < 0 ? -1 : 1, B, [[free, at.y]]);
+        o.position.x += free - at.x;
+        if (skin != null) o.position.z += skin + (z.side < 0 ? -1 : 1) * (size.z / 2) - at.z;
+      }
+    }
+    c.root.updateMatrixWorld(true);
+  }
+  /** The glass of a drawn mirror sits inside its rounded housing, without corners standing past it. */
+  seatMirrorGlass(glass) {
+    const g = glass.geometry.clone();
+    g.computeBoundingBox();
+    const mid = g.boundingBox.getCenter(new this.THREE.Vector3());
+    g.translate(-mid.x, -mid.y, -mid.z);
+    g.scale(MIRROR_GLASS_FIT, MIRROR_GLASS_FIT, MIRROR_GLASS_FIT);
+    g.translate(mid.x, mid.y, mid.z);
+    glass.geometry = g;
+    glass.material = this.I.makeMaterial(MIRROR_GLASS_COLOR, { metalness: 0.95, roughness: 0.12 });
+  }
+  /** The mirror the model already draws around where the part says, if it draws one. */
+  drawnMirror(p) {
+    const THREE = this.THREE;
+    const [cx, cy, cz] = p.box.center;
+    this.c.root.updateMatrixWorld(true);
+    const inv = this.I.worldInverseOf(this.c);
+    const small = this.c.vehicle.children.flatMap((o) => {
+      if (o.userData.glass || o.userData.decal || !(o.isMesh || o.isGroup) || !o.visible || this.c.deform?.includes(o)) return [];
+      const box = this.I.localBox(this.c, o, inv);
+      if (box.isEmpty()) return [];
+      const size = box.getSize(new THREE.Vector3());
+      return Math.max(size.x, size.y, size.z) < DRAWN_MIRROR_SIZE ? [{ o, at: box.getCenter(new THREE.Vector3()) }] : [];
+    });
+    const housing = small.filter(({ at }) => Math.hypot(at.x - cx, at.y - cy, at.z - cz) < DRAWN_MIRROR_REACH && Math.abs(at.z) > Math.abs(cz) - DRAWN_MIRROR_REACH / 2);
+    return small.filter(({ at }) => housing.some((h) => h.at.distanceTo(at) < DRAWN_MIRROR_MOUNT)).map(({ o }) => o);
+  }
   makeMirror(p) {
+    const drawn = this.drawnMirror(p);
+    if (drawn.length) {
+      for (const o of drawn) {
+        if (!o.isMesh || o.material !== this.I.MATERIALS.chrome) continue;
+        const size = new this.THREE.Box3().setFromObject(o).getSize(new this.THREE.Vector3());
+        if (size.x < MIRROR_GLASS_THIN && size.y > MIRROR_GLASS_MIN && size.z > MIRROR_GLASS_MIN) this.seatMirrorGlass(o);
+      }
+      this.extra.set(p.id, drawn);
+      return;
+    }
     const [cx, cy, cz] = p.box.center;
     const s = cz < 0 ? -1 : 1;
     const mats = this.I.MATERIALS;
@@ -11630,17 +12254,28 @@ var VehicleVisuals = class {
   }
   // ---- marks -------------------------------------------------------------------------------------------------------------------------------
   /** A bullet hole: a dark disc lying on the surface at `point` (`c.vehicle` coordinates). */
-  holeDecal(point, normal, diameter) {
+  holeDecal(point, normal, diameter, part) {
     const THREE = this.THREE;
-    const m = new THREE.Mesh(new THREE.CircleGeometry(Math.max(6e-3, diameter / 2), 10), this.I.MATERIALS.dark);
+    const pane = part?.role === "glass" ? this.panesOf(part).find((g) => g.visible) : void 0;
+    if (part?.role === "glass" && (!pane || pane.userData.glass?.broken)) return;
+    const radius = Math.max(6e-3, diameter / 2) * HOLE_DECAL_SCALE;
+    const m = new THREE.Mesh(holeDiscGeometry(THREE), holeMaterial(this.kit, part?.material ?? "steel"));
+    m.scale.set(radius, radius, 1);
     const n = new THREE.Vector3(...normal);
-    m.position.set(...point).addScaledVector(n, 4e-3);
-    m.lookAt(m.position.clone().add(n));
+    m.position.set(...point).addScaledVector(n, 3e-3);
+    this.c.vehicle.add(m);
+    m.lookAt(this.c.vehicle.localToWorld(m.position.clone().add(n)));
     m.userData.decal = true;
     m.userData.noFollow = true;
+    m.renderOrder = 3;
     m.raycast = () => {
     };
-    this.c.vehicle.add(m);
+    const carrier = (part && (this.plates.get(part.id) ?? (part.id === this.hood?.id ? this.c.hood?.piv : void 0))) ?? (pane && pane.parent !== this.c.vehicle ? pane.parent : null);
+    if (carrier) carrier.attach(m);
+  }
+  /** The door or lid a hinge group stands for. */
+  plateIdOf(o) {
+    return o.userData.plateOf;
   }
   spark(point, dir, count = 8) {
     const V3 = this.THREE.Vector3;
@@ -11680,10 +12315,8 @@ var VehicleVisuals = class {
   }
   /** Glass: cracks (laminated) or shatters (tempered); returns whether it broke. */
   hitGlass(p, point, dir, force) {
-    const z = this.zone(p);
-    if (!z) return false;
     const V3 = this.THREE.Vector3;
-    const list = z.glass.filter((g) => g.parent && g.visible);
+    const list = this.panesOf(p).filter((g) => g.parent && g.visible);
     if (!list.length) return false;
     const pt = new V3(...point);
     let best = list[0];
@@ -11700,9 +12333,16 @@ var VehicleVisuals = class {
     this.kit.hitGlass(this.c, best, pt, new V3(...dir), force);
     return !!best.userData.glass?.broken;
   }
+  panesOf(p) {
+    return p.panes ?? this.zone(p)?.glass ?? [];
+  }
   glassBreak(p) {
     const z = this.zone(p);
-    if (!z) return;
+    if (!z) {
+      for (const g of p.panes ?? []) if (g.parent && g.visible) this.kit.hitGlass(this.c, g, g.position.clone(), new this.THREE.Vector3(0, -1, 0), 0.6);
+      this.gone.add(p.id);
+      return;
+    }
     for (const g of z.glass) if (g.parent && g.visible) this.I.glassBand(this.c, z, g, 4);
     this.gone.add(p.id);
   }
@@ -11730,6 +12370,7 @@ var VehicleVisuals = class {
   smoothLater(msh) {
     this.smoothing.set(msh, this.I.creaseTask(msh.geometry, 42));
     this.tornThisFrame = true;
+    this.holdArmed = true;
   }
   /** Spends at most `budgetMs` finishing the pending normal smoothing. Call once per frame. */
   pump(budgetMs = 2.5) {
@@ -11737,6 +12378,7 @@ var VehicleVisuals = class {
       this.tornThisFrame = false;
       return;
     }
+    if (this.queued) return;
     if (!this.smoothing.size && !this.warming) return;
     const deadline = performance.now() + budgetMs;
     for (const [msh, task] of this.smoothing) {
@@ -11745,6 +12387,34 @@ var VehicleVisuals = class {
     }
     this.warmIndexes(deadline);
   }
+  setQueued(isQueued) {
+    this.queued = isQueued;
+  }
+  /** Units the shared queue may run now: 0 in the frame of the cut (the first ask after it holds the work for that frame, or `pump` closes it when there is no frame). */
+  pendingUnits(frame) {
+    if (this.holdArmed && frame !== void 0) {
+      this.holdArmed = false;
+      this.holdFrame = frame;
+    }
+    if (frame !== void 0 && frame === this.holdFrame) return 0;
+    if (frame === void 0 && this.tornThisFrame) return 0;
+    return this.smoothing.size + (this.warming ? 1 : 0);
+  }
+  /** One slice of the pending work, for the shared queue. */
+  runStep(deadline) {
+    const next = this.smoothing.entries().next();
+    if (!next.done) {
+      const [msh, task] = next.value;
+      if (msh.geometry !== task.geo || task.step(deadline)) this.smoothing.delete(msh);
+      return true;
+    }
+    if (!this.warming) return false;
+    this.warmIndexes(deadline);
+    return true;
+  }
+  finishAll() {
+    while (this.runStep(Infinity)) ;
+  }
   /** Measures the triangles of the heavy body meshes once, a slice per frame, so the first panel torn off finds them ready (see `triIndexOf`). */
   warmIndexes(deadline) {
     if (!this.warming) return;
@@ -11916,6 +12586,7 @@ var VehicleVisuals = class {
     }
     pieceTasks.forEach((task, mesh) => this.smoothing.set(mesh, task));
     this.tornThisFrame = true;
+    this.holdArmed = true;
     dirty.forEach((msh) => {
       const g = msh.geometry;
       if (g.userData.crease || !g.index) this.smoothLater(msh);
@@ -12022,6 +12693,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
   let clock = 0;
   let model;
   let vis = null;
+  let releaseCrease;
   const ps = /* @__PURE__ */ new Map();
   let js = [];
   let leaks = /* @__PURE__ */ new Map();
@@ -12106,7 +12778,9 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     rand = rng(seedBase);
     igniteRand = rng(strHash(`${c.key}|${id}|ignition|${options.seed ?? 0}`));
     steerSign = rand() < 0.5 ? -1 : 1;
+    releaseCrease?.();
     vis = headless ? null : new VehicleVisuals(kit, c, model);
+    releaseCrease = vis && options.creaseQueue ? options.creaseQueue.track(vis) : void 0;
     recomputeGroups();
   };
   const recomputeGroups = () => {
@@ -12417,13 +13091,13 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     sync();
     const M = toFrameMatrix();
     const v = toLocal(h.point);
-    const p = locate(v, 0.2);
+    const p = (h.part ? ps.get(h.part) : void 0) ?? locate(v, 0.2);
     if (!p) return;
     const d = p.def;
     const E = h.energy ?? 0;
     const cal = h.caliber ?? 9;
     const dir = dirToLocal(h.direction ?? [0, 0, -1]).normalize();
-    const n = normalOf(d, v);
+    const n = h.normal ? dirToLocal(h.normal).normalize() : normalOf(d, v);
     const res = resist(d, p);
     const through = E >= res;
     const cosInc = Math.abs(dir.dot(n));
@@ -12442,7 +13116,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
       const hp = { point: r3(fromVehicle(v, M)), normal: r3(fromVehicle(n, new THREE.Matrix4().extractRotation(M))), diameter: r2(holeDiam), through };
       p.holes.push(hp);
       out.push(ev({ type: "hole", part: d.id, hole: hp, worldPoint, ...through ? { exitPoint: add3(worldPoint, r3(dirToWorld(dir.clone().multiplyScalar(Math.max(0.02, Math.min(d.box.size[0], d.box.size[1], d.box.size[2])))))) } : {} }));
-      vis?.holeDecal([v.x, v.y, v.z], [n.x, n.y, n.z], holeDiam);
+      vis?.holeDecal([v.x, v.y, v.z], [n.x, n.y, n.z], holeDiam, d);
       startLeak(p, v, cal, out, dir);
     };
     switch (d.material) {
@@ -12743,6 +13417,46 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     for (const p of ps.values()) if (!p.lost && (p.burning || p.temp > AMBIENT)) return true;
     return false;
   };
+  const surfaceRays = new THREE.Raycaster();
+  surfaceRays.layers.enableAll();
+  surfaceRays.camera = new THREE.PerspectiveCamera();
+  let meshParts = null;
+  const paneParts = () => {
+    if (meshParts) return meshParts;
+    meshParts = /* @__PURE__ */ new Map();
+    for (const d of model.parts) {
+      if (d.role !== "glass") continue;
+      const z = kit.zonesOf(c).find((q) => q.id === d.zoneId);
+      for (const g of z?.glass ?? d.panes ?? []) meshParts.set(g, d.id);
+    }
+    return meshParts;
+  };
+  const isDrawnSurface = (o) => {
+    for (let q = o; q && q !== c.vehicle; q = q.parent) if (!q.visible || q.userData.decal || q.userData.ghost) return false;
+    return true;
+  };
+  const partOfSurface = (o, v) => {
+    const pane = paneParts().get(o);
+    if (pane) return ps.get(pane) ?? null;
+    for (let q = o; q && q !== c.vehicle; q = q.parent) {
+      if (vis?.plateIdOf(q)) return ps.get(vis.plateIdOf(q)) ?? null;
+    }
+    return locate(v, 0.08, (p) => p.def.role === "glass");
+  };
+  const surfaceRay = (ray) => {
+    sync();
+    surfaceRays.set(new V3(ray.origin[0], ray.origin[1], ray.origin[2]), new V3(ray.direction[0], ray.direction[1], ray.direction[2]));
+    surfaceRays.far = ray.maxDistance;
+    for (const h of surfaceRays.intersectObject(c.vehicle, true)) {
+      if (!h.face || !isDrawnSurface(h.object)) continue;
+      const p = partOfSurface(h.object, c.vehicle.worldToLocal(h.point.clone()));
+      if (!p || p.lost || ray.ignored?.(p.def.id)) continue;
+      const n = h.face.normal.clone().transformDirection(h.object.matrixWorld);
+      if (n.dot(surfaceRays.ray.direction) > 0) n.negate();
+      return { part: p.def.id, point: [h.point.x, h.point.y, h.point.z], normal: [n.x, n.y, n.z], distance: h.distance, pathLen: 0.02 };
+    }
+    return null;
+  };
   const hit = (h) => {
     stateCache = void 0;
     const out = [];
@@ -12865,9 +13579,14 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     },
     describe,
     hit,
+    surfaceRay,
     update,
     state,
     reset,
+    dispose: () => {
+      releaseCrease?.();
+      releaseCrease = void 0;
+    },
     disassemble,
     extinguish,
     serialize: () => ({
@@ -12906,6 +13625,62 @@ function buildVehicleItem(kit, key, options = {}) {
   return { root, vehicle };
 }
 
+// src/destructible/crease-queue.ts
+import { DEFERRED_QUEUE_ID } from "@adatechnology/game-contracts";
+function createCreaseQueue() {
+  const tracked = [];
+  let cursor = 0;
+  let lastFrame;
+  let attached = false;
+  const deferred = {
+    id: DEFERRED_QUEUE_ID.VEHICLE_CREASE,
+    pending(frame) {
+      lastFrame = frame;
+      let units = 0;
+      for (const work of tracked) units += work.pendingUnits(frame);
+      return units;
+    },
+    run(deadline, clock) {
+      let ran = 0;
+      let skipped = 0;
+      while (tracked.length > 0 && skipped < tracked.length) {
+        if (ran > 0 && clock() >= deadline) break;
+        const work = tracked[cursor % tracked.length];
+        cursor = (cursor + 1) % tracked.length;
+        if (work.pendingUnits(lastFrame) > 0 && work.runStep(deadline)) {
+          ran++;
+          skipped = 0;
+        } else skipped++;
+      }
+      return ran;
+    },
+    flush() {
+      for (const work of tracked) work.finishAll();
+    },
+    attach() {
+      attached = true;
+      for (const work of tracked) work.setQueued(true);
+    },
+    detach() {
+      attached = false;
+      for (const work of tracked) work.setQueued(false);
+    }
+  };
+  return {
+    deferredQueue: () => deferred,
+    track(work) {
+      tracked.push(work);
+      work.setQueued(attached);
+      return () => {
+        const at = tracked.indexOf(work);
+        if (at < 0) return;
+        tracked.splice(at, 1);
+        work.setQueued(false);
+      };
+    }
+  };
+}
+
 // src/destructible/enclosure.ts
 var CABIN_LEAK = 0.02;
 var HOLE_RATE_PER_AREA = 3e3;
@@ -13000,6 +13775,8 @@ export {
   cabinBoxOf,
   cabinEnclosure,
   clamp,
+  crackedGlassMaterial,
+  createCreaseQueue,
   createLod,
   createTranslate,
   createVehicleDestructible,