@adatechnology/game-vehicles 0.4.5 → 0.4.7

package/dist/index.global.js

@@ -580,12 +580,12 @@ var GameVehicles = (() => {
       return triangles;
     }
   };
-  function linkedList(data, start, end, dim, clockwise) {
+  function linkedList(data, start2, end, dim, clockwise) {
     let i, last;
-    if (clockwise === signedArea(data, start, end, dim) > 0) {
-      for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
+    if (clockwise === signedArea(data, start2, end, dim) > 0) {
+      for (i = start2; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
     } else {
-      for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
+      for (i = end - dim; i >= start2; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
     }
     if (last && equals(last, last.next)) {
       removeNode(last);
@@ -593,10 +593,10 @@ var GameVehicles = (() => {
     }
     return last;
   }
-  function filterPoints(start, end) {
-    if (!start) return start;
-    if (!end) end = start;
-    let p = start, again;
+  function filterPoints(start2, end) {
+    if (!start2) return start2;
+    if (!end) end = start2;
+    let p = start2, again;
     do {
       again = false;
       if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
@@ -675,8 +675,8 @@ var GameVehicles = (() => {
     }
     return true;
   }
-  function cureLocalIntersections(start, triangles, dim) {
-    let p = start;
+  function cureLocalIntersections(start2, triangles, dim) {
+    let p = start2;
     do {
       const a = p.prev, b = p.next.next;
       if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
@@ -685,14 +685,14 @@ var GameVehicles = (() => {
         triangles.push(b.i / dim | 0);
         removeNode(p);
         removeNode(p.next);
-        p = start = b;
+        p = start2 = b;
       }
       p = p.next;
-    } while (p !== start);
+    } while (p !== start2);
     return filterPoints(p);
   }
-  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
-    let a = start;
+  function splitEarcut(start2, triangles, dim, minX, minY, invSize) {
+    let a = start2;
     do {
       let b = a.next.next;
       while (b !== a.prev) {
@@ -707,15 +707,15 @@ var GameVehicles = (() => {
         b = b.next;
       }
       a = a.next;
-    } while (a !== start);
+    } while (a !== start2);
   }
   function eliminateHoles(data, holeIndices, outerNode, dim) {
     const queue = [];
-    let i, len, start, end, list2;
+    let i, len, start2, end, list2;
     for (i = 0, len = holeIndices.length; i < len; i++) {
-      start = holeIndices[i] * dim;
+      start2 = holeIndices[i] * dim;
       end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-      list2 = linkedList(data, start, end, dim, false);
+      list2 = linkedList(data, start2, end, dim, false);
       if (list2 === list2.next) list2.steiner = true;
       queue.push(getLeftmost(list2));
     }
@@ -770,14 +770,14 @@ var GameVehicles = (() => {
   function sectorContainsSector(m, p) {
     return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
   }
-  function indexCurve(start, minX, minY, invSize) {
-    let p = start;
+  function indexCurve(start2, minX, minY, invSize) {
+    let p = start2;
     do {
       if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
       p.prevZ = p.prev;
       p.nextZ = p.next;
       p = p.next;
-    } while (p !== start);
+    } while (p !== start2);
     p.prevZ.nextZ = null;
     p.prevZ = null;
     sortLinked(p);
@@ -834,12 +834,12 @@ var GameVehicles = (() => {
     y = (y | y << 1) & 1431655765;
     return x | y << 1;
   }
-  function getLeftmost(start) {
-    let p = start, leftmost = start;
+  function getLeftmost(start2) {
+    let p = start2, leftmost = start2;
     do {
       if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) leftmost = p;
       p = p.next;
-    } while (p !== start);
+    } while (p !== start2);
     return leftmost;
   }
   function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
@@ -938,9 +938,9 @@ var GameVehicles = (() => {
     this.nextZ = null;
     this.steiner = false;
   }
-  function signedArea(data, start, end, dim) {
+  function signedArea(data, start2, end, dim) {
     let sum = 0;
-    for (let i = start, j = end - dim; i < end; i += dim) {
+    for (let i = start2, j = end - dim; i < end; i += dim) {
       sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
       j = i;
     }
@@ -1197,7 +1197,7 @@ var GameVehicles = (() => {
       const uvs = [uv(iA), uv(iB), uv(iC), uv(iD)];
       for (const k of [0, 1, 3, 1, 2, 3]) addUV(...uvs[k]);
     };
-    let start = verticesArray.length / 3;
+    let start2 = verticesArray.length / 3;
     if (bevelEnabled) {
       let offset = 0;
       for (let i = 0; i < flen; i++) {
@@ -1220,8 +1220,8 @@ var GameVehicles = (() => {
         f3(face[0] + vlen * steps, face[1] + vlen * steps, face[2] + vlen * steps);
       }
     }
-    groups.push({ start, count: verticesArray.length / 3 - start, materialIndex: 0 });
-    start = verticesArray.length / 3;
+    groups.push({ start: start2, count: verticesArray.length / 3 - start2, materialIndex: 0 });
+    start2 = verticesArray.length / 3;
     const sidewalls = (ring2, layeroffset2) => {
       let i = ring2.length;
       while (--i >= 0) {
@@ -1242,7 +1242,7 @@ var GameVehicles = (() => {
       sidewalls(ahole, layeroffset);
       layeroffset += ahole.length;
     }
-    groups.push({ start, count: verticesArray.length / 3 - start, materialIndex: 1 });
+    groups.push({ start: start2, count: verticesArray.length / 3 - start2, materialIndex: 1 });
     const positions = new Float32Array(verticesArray);
     return { type: "ExtrudeGeometry", parameters, positions, normals: computeVertexNormals(positions), uvs: new Float32Array(uvArray), groups };
   }
@@ -1518,8 +1518,8 @@ var GameVehicles = (() => {
   var shims = /* @__PURE__ */ new WeakSet();
   function shapeGeometries(THREE, options = {}) {
     if (shims.has(THREE)) return THREE;
-    const cache = options.cache !== false;
-    const key = cache ? "cache" : "nocache";
+    const cache2 = options.cache !== false;
+    const key = cache2 ? "cache" : "nocache";
     let byKey = namespaces.get(THREE);
     if (!byKey) {
       byKey = /* @__PURE__ */ new Map();
@@ -1528,7 +1528,7 @@ var GameVehicles = (() => {
     const existing = byKey.get(key);
     if (existing) return existing;
     const made = (p) => toGeometry(THREE, p);
-    const viaCache = (node, direct) => cache ? buildPrimitive(node) : direct();
+    const viaCache = (node, direct) => cache2 ? buildPrimitive(node) : direct();
     const defined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
     const constructors = {
       BoxGeometry: (width, height, depth, ws = 1, hs = 1, ds = 1) => made(viaCache({ kind: "box", size: [width ?? 1, height ?? 1, depth ?? 1], segments: [ws, hs, ds] }, () => box(width, height, depth, ws, hs, ds))),
@@ -2224,7 +2224,7 @@ var GameVehicles = (() => {
     const I = kit._;
     const document2 = kit.document;
     const RUST = new THREE.Color("#5e3220");
-    const cache = {};
+    const cache2 = {};
     let envTex = null;
     function studioEnvironment() {
       if (envTex) return envTex;
@@ -2269,7 +2269,7 @@ var GameVehicles = (() => {
       const key = "s" + c.getHexString() + JSON.stringify(o, function(k, v) {
         return v && v.isColor ? "#" + v.getHexString() : v && v.isTexture ? v.uuid : v;
       });
-      if (!cache[key]) {
+      if (!cache2[key]) {
         const o2 = Object.assign({}, o);
         delete o2.noEnv;
         const mt = new THREE.MeshStandardMaterial(Object.assign({ color: c, roughness: 0.8, metalness: 0, flatShading: false }, o2));
@@ -2277,9 +2277,9 @@ var GameVehicles = (() => {
           mt.envMap = studioEnvironment();
           if (o.envMapIntensity == null) mt.envMapIntensity = 0.55 + (mt.metalness - 0.6) * 1.6;
         }
-        cache[key] = mt;
+        cache2[key] = mt;
       }
-      return cache[key];
+      return cache2[key];
     }
     function makeFlatMaterial(color2, o) {
       return makeMaterial(color2, Object.assign({ flatShading: true, roughness: 0.92 }, o || {}));
@@ -2394,7 +2394,131 @@ var GameVehicles = (() => {
       return t;
     }
     kit.textTexture = textTexture;
-    Object.assign(I, { RUST, cache, studioEnvironment, makeMaterial, makeFlatMaterial, DOUBLE_SIDE, toColor, MATERIALS, paintColor, texCache, textTexture });
+    Object.assign(I, { RUST, cache: cache2, studioEnvironment, makeMaterial, makeFlatMaterial, DOUBLE_SIDE, toColor, MATERIALS, paintColor, texCache, textTexture });
+  }
+
+  // src/tri-index.ts
+  var TRI_BLOCK = 32;
+  var cache = /* @__PURE__ */ new WeakMap();
+  function trianglesOf(geo) {
+    return Math.floor((geo.index ? geo.index.count : geo.attributes.position.count) / 3);
+  }
+  function supports(geo) {
+    const pos = geo.attributes && geo.attributes.position;
+    return !!pos && !pos.isInterleavedBufferAttribute && pos.itemSize === 3;
+  }
+  function isCurrent(geo, ti) {
+    const pos = geo.attributes.position;
+    return ti.position === pos && ti.positionVersion === pos.version && ti.index === (geo.index || null) && ti.indexVersion === (geo.index ? geo.index.version : 0) && ti.triangles === trianglesOf(geo);
+  }
+  function blockCount(triangles) {
+    return Math.ceil(triangles / TRI_BLOCK);
+  }
+  function boxBlock(ti, block) {
+    const B = ti.boxes;
+    const t0 = block * TRI_BLOCK;
+    const t1 = Math.min(ti.triangles, t0 + TRI_BLOCK);
+    const o = block * 6;
+    for (let k = 0; k < 3; k++) {
+      ti.blocks[o + k] = Infinity;
+      ti.blocks[o + 3 + k] = -Infinity;
+    }
+    for (let t = t0; t < t1; t++) {
+      const j = t * 6;
+      for (let k = 0; k < 3; k++) {
+        if (B[j + k] < ti.blocks[o + k]) ti.blocks[o + k] = B[j + k];
+        if (B[j + 3 + k] > ti.blocks[o + 3 + k]) ti.blocks[o + 3 + k] = B[j + 3 + k];
+      }
+    }
+  }
+  function boxTriangle(geo, ti, t) {
+    const P = geo.attributes.position.array;
+    const ix = geo.index ? geo.index.array : null;
+    const a = (ix ? ix[t * 3] : t * 3) * 3;
+    const b = (ix ? ix[t * 3 + 1] : t * 3 + 1) * 3;
+    const c = (ix ? ix[t * 3 + 2] : t * 3 + 2) * 3;
+    const j = t * 6;
+    for (let k = 0; k < 3; k++) {
+      ti.boxes[j + k] = Math.min(P[a + k], P[b + k], P[c + k]);
+      ti.boxes[j + 3 + k] = Math.max(P[a + k], P[b + k], P[c + k]);
+    }
+  }
+  function advance(geo, ti, deadline) {
+    const total = blockCount(ti.triangles);
+    while (ti.builtBlocks < total) {
+      const block = ti.builtBlocks;
+      const t1 = Math.min(ti.triangles, (block + 1) * TRI_BLOCK);
+      for (let t = block * TRI_BLOCK; t < t1; t++) boxTriangle(geo, ti, t);
+      boxBlock(ti, block);
+      ti.builtBlocks++;
+      if (deadline !== Infinity && performance.now() >= deadline) break;
+    }
+    return ti.builtBlocks === total;
+  }
+  function start(geo) {
+    const pos = geo.attributes.position;
+    const triangles = trianglesOf(geo);
+    const ti = {
+      position: pos,
+      positionVersion: pos.version,
+      index: geo.index || null,
+      indexVersion: geo.index ? geo.index.version : 0,
+      triangles,
+      boxes: new Float64Array(triangles * 6),
+      blocks: new Float64Array(blockCount(triangles) * 6),
+      builtBlocks: 0
+    };
+    cache.set(geo, ti);
+    return ti;
+  }
+  function triIndexOf(geo) {
+    if (!supports(geo)) return void 0;
+    let ti = cache.get(geo);
+    if (!ti || !isCurrent(geo, ti)) ti = start(geo);
+    advance(geo, ti, Infinity);
+    return ti;
+  }
+  function warmTriIndex(geo, deadline) {
+    if (!supports(geo)) return true;
+    let ti = cache.get(geo);
+    if (!ti || !isCurrent(geo, ti)) ti = start(geo);
+    return advance(geo, ti, deadline);
+  }
+  function storeTriIndex(geo, boxes) {
+    const ti = start(geo);
+    ti.boxes = boxes;
+    const total = blockCount(ti.triangles);
+    for (let b = 0; b < total; b++) boxBlock(ti, b);
+    ti.builtBlocks = total;
+  }
+  function liveTriIndex(geo) {
+    if (geo.index || !supports(geo)) return void 0;
+    const ti = cache.get(geo);
+    return ti && isCurrent(geo, ti) && ti.builtBlocks === blockCount(ti.triangles) ? ti : void 0;
+  }
+  function touchTriIndex(geo, ti, vertices) {
+    if (ti.positionVersion + 1 !== geo.attributes.position.version) return;
+    const blocks = /* @__PURE__ */ new Set();
+    for (const v of vertices) {
+      const t = Math.floor(v / 3);
+      if (t >= ti.triangles) continue;
+      boxTriangle(geo, ti, t);
+      blocks.add(Math.floor(t / TRI_BLOCK));
+    }
+    blocks.forEach((b) => boxBlock(ti, b));
+    ti.positionVersion = geo.attributes.position.version;
+  }
+  function boundsFromIndex(geo) {
+    if (geo.index || !supports(geo)) return void 0;
+    const ti = cache.get(geo);
+    if (!ti || !isCurrent(geo, ti) || ti.builtBlocks !== blockCount(ti.triangles) || !ti.triangles || geo.attributes.position.count !== ti.triangles * 3) return void 0;
+    const box2 = new Float64Array([Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity]);
+    for (let b = 0, n = blockCount(ti.triangles); b < n; b++)
+      for (let k = 0; k < 3; k++) {
+        box2[k] = Math.min(box2[k], ti.blocks[b * 6 + k]);
+        box2[3 + k] = Math.max(box2[3 + k], ti.blocks[b * 6 + 3 + k]);
+      }
+    return { box: box2, version: ti.positionVersion };
   }
 
   // src/geometry.ts
@@ -2491,7 +2615,8 @@ var GameVehicles = (() => {
       g.userData.crease = true;
       return g;
     }
-    function crease(geo, deg) {
+    const latestCrease = /* @__PURE__ */ new WeakMap();
+    function creaseTask(geo, deg) {
       if (geo.index) {
         const ni = geo.toNonIndexed();
         Object.keys(ni.attributes).forEach(function(k) {
@@ -2499,30 +2624,22 @@ var GameVehicles = (() => {
         });
         geo.setIndex(null);
       }
-      const p = geo.attributes.position;
-      const n = p.count;
+      const P = geo.attributes.position.array;
+      const n = geo.attributes.position.count;
       const faces = n / 3;
       const FN = new Float64Array(faces * 3);
-      const map = /* @__PURE__ */ new Map();
-      const RANGE = 65536;
-      function key(i) {
-        const x = Math.round(p.getX(i) * 2e3);
-        const y = Math.round(p.getY(i) * 2e3);
-        const z = Math.round(p.getZ(i) * 2e3);
-        if (Math.abs(x) < RANGE && Math.abs(y) < RANGE && Math.abs(z) < RANGE) return ((x + RANGE) * 131072 + (y + RANGE)) * 131072 + (z + RANGE);
-        return x + "," + y + "," + z;
-      }
-      const keys = new Array(n);
+      const out = new Float32Array(n * 3);
       for (let f = 0; f < faces; f++) {
-        const ax = p.getX(3 * f);
-        const ay = p.getY(3 * f);
-        const az = p.getZ(3 * f);
-        const bx = p.getX(3 * f + 1);
-        const by = p.getY(3 * f + 1);
-        const bz = p.getZ(3 * f + 1);
-        const cx = p.getX(3 * f + 2);
-        const cy = p.getY(3 * f + 2);
-        const cz = p.getZ(3 * f + 2);
+        const o = 9 * f;
+        const ax = P[o];
+        const ay = P[o + 1];
+        const az = P[o + 2];
+        const bx = P[o + 3];
+        const by = P[o + 4];
+        const bz = P[o + 5];
+        const cx = P[o + 6];
+        const cy = P[o + 7];
+        const cz = P[o + 8];
         const e1x = cx - bx;
         const e1y = cy - by;
         const e1z = cz - bz;
@@ -2542,41 +2659,109 @@ var GameVehicles = (() => {
         FN[3 * f + 1] = ny;
         FN[3 * f + 2] = nz;
         for (let k = 0; k < 3; k++) {
-          const kk = key(3 * f + k);
-          keys[3 * f + k] = kk;
-          const list2 = map.get(kk);
-          if (list2) list2.push(f);
-          else map.set(kk, [f]);
+          out[9 * f + 3 * k] = nx;
+          out[9 * f + 3 * k + 1] = ny;
+          out[9 * f + 3 * k + 2] = nz;
+        }
+      }
+      const normal = new THREE.BufferAttribute(out, 3);
+      geo.setAttribute("normal", normal);
+      const token = {};
+      latestCrease.set(geo, token);
+      let size = 16;
+      while (size < n * 2) size *= 2;
+      const mask = size - 1;
+      const slot = new Int32Array(size).fill(-1);
+      const gx = new Int32Array(n);
+      const gy = new Int32Array(n);
+      const gz = new Int32Array(n);
+      const groupOf = new Int32Array(n);
+      let groups = 0;
+      let start2;
+      let members;
+      const cs = Math.cos(deg * PI / 180);
+      let phase = 0;
+      let at = 0;
+      function hashSlice(deadline) {
+        for (; at < n; at++) {
+          if ((at & 1023) === 0 && performance.now() > deadline) return false;
+          const x = Math.round(P[3 * at] * 2e3) | 0;
+          const y = Math.round(P[3 * at + 1] * 2e3) | 0;
+          const z = Math.round(P[3 * at + 2] * 2e3) | 0;
+          let h = (Math.imul(x, 73856093) ^ Math.imul(y, 19349663) ^ Math.imul(z, 83492791)) & mask;
+          let g = slot[h];
+          while (g >= 0 && (gx[g] !== x || gy[g] !== y || gz[g] !== z)) {
+            h = h + 1 & mask;
+            g = slot[h];
+          }
+          if (g < 0) {
+            g = groups++;
+            slot[h] = g;
+            gx[g] = x;
+            gy[g] = y;
+            gz[g] = z;
+          }
+          groupOf[at] = g;
         }
+        return true;
       }
-      const cs = Math.cos(deg * PI / 180);
-      const out = new Float32Array(n * 3);
-      for (let i = 0; i < n; i++) {
-        const fi = (i / 3 | 0) * 3;
-        const list2 = map.get(keys[i]);
-        let sx = 0;
-        let sy = 0;
-        let sz = 0;
-        for (let j = 0; j < list2.length; j++) {
-          const g = list2[j] * 3;
-          if (FN[g] * FN[fi] + FN[g + 1] * FN[fi + 1] + FN[g + 2] * FN[fi + 2] >= cs) {
-            sx += FN[g];
-            sy += FN[g + 1];
-            sz += FN[g + 2];
+      function gather() {
+        start2 = new Int32Array(groups + 1);
+        for (let i = 0; i < n; i++) start2[groupOf[i] + 1]++;
+        for (let g = 0; g < groups; g++) start2[g + 1] += start2[g];
+        const fill = start2.slice(0, groups);
+        members = new Int32Array(n);
+        for (let i = 0; i < n; i++) members[fill[groupOf[i]]++] = i / 3 | 0;
+      }
+      function smoothSlice(deadline) {
+        for (; at < n; at++) {
+          if ((at & 1023) === 0 && performance.now() > deadline) return false;
+          const fi = (at / 3 | 0) * 3;
+          const g = groupOf[at];
+          let sx = 0;
+          let sy = 0;
+          let sz = 0;
+          for (let j = start2[g], end = start2[g + 1]; j < end; j++) {
+            const o = members[j] * 3;
+            if (FN[o] * FN[fi] + FN[o + 1] * FN[fi + 1] + FN[o + 2] * FN[fi + 2] >= cs) {
+              sx += FN[o];
+              sy += FN[o + 1];
+              sz += FN[o + 2];
+            }
           }
+          if (sx * sx + sy * sy + sz * sz < 1e-20) {
+            sx = FN[fi];
+            sy = FN[fi + 1];
+            sz = FN[fi + 2];
+          }
+          const inv = 1 / (Math.sqrt(sx * sx + sy * sy + sz * sz) || 1);
+          out[3 * at] = sx * inv;
+          out[3 * at + 1] = sy * inv;
+          out[3 * at + 2] = sz * inv;
         }
-        if (sx * sx + sy * sy + sz * sz < 1e-20) {
-          sx = FN[fi];
-          sy = FN[fi + 1];
-          sz = FN[fi + 2];
+        return true;
+      }
+      function step(deadline) {
+        if (latestCrease.get(geo) !== token) return true;
+        if (phase === 0) {
+          if (!hashSlice(deadline)) return false;
+          gather();
+          phase = 1;
+          at = 0;
+        }
+        if (phase === 1) {
+          const done = smoothSlice(deadline);
+          if (deadline !== Infinity) normal.needsUpdate = true;
+          if (!done) return false;
+          phase = 2;
+          geo.userData.crease = true;
         }
-        const inv = 1 / (Math.sqrt(sx * sx + sy * sy + sz * sz) || 1);
-        out[3 * i] = sx * inv;
-        out[3 * i + 1] = sy * inv;
-        out[3 * i + 2] = sz * inv;
+        return true;
       }
-      geo.setAttribute("normal", new THREE.BufferAttribute(out, 3));
-      geo.userData.crease = true;
+      return { geo, step };
+    }
+    function crease(geo, deg) {
+      creaseTask(geo, deg).step(Infinity);
       return geo;
     }
     function pathShape(items) {
@@ -2723,28 +2908,28 @@ var GameVehicles = (() => {
       return g;
     }
     function cutGeometry(geo, tests) {
-      const src = geo.index ? geo.toNonIndexed() : geo;
+      const idx = geo.index ? geo.index.array : null;
       const names = ["position"].concat(
         ["color", "uv"].filter(function(n2) {
-          return !!src.attributes[n2];
+          return !!geo.attributes[n2];
         })
       );
       const sizes = names.map(function(n2) {
-        return src.attributes[n2].itemSize;
+        return geo.attributes[n2].itemSize;
       });
       const arrs = names.map(function(n2) {
-        return src.attributes[n2].array;
+        return geo.attributes[n2].array;
       });
-      const nv = src.attributes.position.count;
-      let tris = [];
-      for (let f = 0; f < nv; f += 3) {
+      const nv = idx ? idx.length : geo.attributes.position.count;
+      function readTri(f) {
         const t = [];
         for (let k = 0; k < 3; k++) {
+          const vi = idx ? idx[f + k] : f + k;
           const v = [];
-          for (let a = 0; a < names.length; a++) for (let q = 0; q < sizes[a]; q++) v.push(arrs[a][(f + k) * sizes[a] + q]);
+          for (let a = 0; a < names.length; a++) for (let q = 0; q < sizes[a]; q++) v.push(arrs[a][vi * sizes[a] + q]);
           t.push(v);
         }
-        tris.push(t);
+        return t;
       }
       const cut = {};
       const n = new V3();
@@ -2770,60 +2955,177 @@ var GameVehicles = (() => {
       function fan(poly, arr) {
         for (let i = 1; i < poly.length - 1; i++) arr.push([poly[0], poly[i], poly[i + 1]]);
       }
-      tests.forEach(function(T) {
-        const next = [];
+      function testTri(T, t, next, rem) {
+        const A = t[0];
+        const B = t[1];
+        const C = t[2];
+        e1.set(B[0] - A[0], B[1] - A[1], B[2] - A[2]);
+        e2.set(C[0] - A[0], C[1] - A[1], C[2] - A[2]);
+        n.crossVectors(e1, e2);
+        const len = n.length();
+        if (len < 1e-12) {
+          next.push(t);
+          return;
+        }
+        n.multiplyScalar(1 / len);
+        ce.set((A[0] + B[0] + C[0]) / 3, (A[1] + B[1] + C[1]) / 3, (A[2] + B[2] + C[2]) / 3);
+        if (T.sel && !T.sel(n, ce)) {
+          next.push(t);
+          return;
+        }
+        const d = [T.sdf(A[0], A[1], A[2]), T.sdf(B[0], B[1], B[2]), T.sdf(C[0], C[1], C[2])];
+        const ins = (d[0] < 0 ? 1 : 0) + (d[1] < 0 ? 1 : 0) + (d[2] < 0 ? 1 : 0);
+        if (ins === 0) next.push(t);
+        else if (ins === 3) {
+          if (rem) rem.push(t);
+        } else {
+          fan(clip(t, d, 1), next);
+          if (rem) fan(clip(t, d, -1), rem);
+        }
+      }
+      const segments = [];
+      let total = 0;
+      const ti = tests.length === 1 && tests[0].bounds ? triIndexOf(geo) : void 0;
+      if (ti) {
+        const T = tests[0];
+        const lo = T.bounds.lo;
+        const hi = T.bounds.hi;
         const rem = T.tag ? cut[T.tag] = cut[T.tag] || [] : null;
-        tris.forEach(function(t) {
-          const A = t[0];
-          const B = t[1];
-          const C = t[2];
-          e1.set(B[0] - A[0], B[1] - A[1], B[2] - A[2]);
-          e2.set(C[0] - A[0], C[1] - A[1], C[2] - A[2]);
-          n.crossVectors(e1, e2);
-          const len = n.length();
-          if (len < 1e-12) {
-            next.push(t);
-            return;
-          }
-          n.multiplyScalar(1 / len);
-          ce.set((A[0] + B[0] + C[0]) / 3, (A[1] + B[1] + C[1]) / 3, (A[2] + B[2] + C[2]) / 3);
-          if (T.sel && !T.sel(n, ce)) {
-            next.push(t);
-            return;
+        const boxes = ti.boxes;
+        const blocks = ti.blocks;
+        let runFrom = -1;
+        const closeRun = function(end) {
+          if (runFrom < 0) return;
+          segments.push([runFrom, end]);
+          total += end - runFrom;
+          runFrom = -1;
+        };
+        for (let blk = 0, t0 = 0; t0 < ti.triangles; blk++, t0 += TRI_BLOCK) {
+          const j = blk * 6;
+          if (blocks[j + 3] < lo[0] || blocks[j] > hi[0] || blocks[j + 4] < lo[1] || blocks[j + 1] > hi[1] || blocks[j + 5] < lo[2] || blocks[j + 2] > hi[2]) {
+            if (runFrom < 0) runFrom = t0;
+            continue;
           }
-          const d = [T.sdf(A[0], A[1], A[2]), T.sdf(B[0], B[1], B[2]), T.sdf(C[0], C[1], C[2])];
-          const ins = (d[0] < 0 ? 1 : 0) + (d[1] < 0 ? 1 : 0) + (d[2] < 0 ? 1 : 0);
-          if (ins === 0) next.push(t);
-          else if (ins === 3) {
-            if (rem) rem.push(t);
-          } else {
-            fan(clip(t, d, 1), next);
-            if (rem) fan(clip(t, d, -1), rem);
+          const t1 = Math.min(ti.triangles, t0 + TRI_BLOCK);
+          for (let t = t0; t < t1; t++) {
+            const q = t * 6;
+            if (boxes[q + 3] < lo[0] || boxes[q] > hi[0] || boxes[q + 4] < lo[1] || boxes[q + 1] > hi[1] || boxes[q + 5] < lo[2] || boxes[q + 2] > hi[2]) {
+              if (runFrom < 0) runFrom = t;
+              continue;
+            }
+            closeRun(t);
+            const next = [];
+            testTri(T, readTri(t * 3), next, rem);
+            if (next.length) {
+              segments.push(next);
+              total += next.length;
+            }
           }
+        }
+        closeRun(ti.triangles);
+      } else {
+        let tris = [];
+        for (let f = 0; f < nv; f += 3) tris.push(readTri(f));
+        tests.forEach(function(T) {
+          const next = [];
+          const rem = T.tag ? cut[T.tag] = cut[T.tag] || [] : null;
+          tris.forEach(function(t) {
+            testTri(T, t, next, rem);
+          });
+          tris = next;
         });
-        tris = next;
-      });
-      function build(list2) {
+        segments.push(tris);
+        total = tris.length;
+      }
+      function fill(segs, count, boxesOut2) {
         const g = new THREE.BufferGeometry();
-        let off = 0;
-        names.forEach(function(nm, a) {
-          const arr = new Float32Array(list2.length * 3 * sizes[a]);
-          let w = 0;
-          list2.forEach(function(t) {
-            for (let k = 0; k < 3; k++) for (let q = 0; q < sizes[a]; q++) arr[w++] = t[k][off + q];
+        const dst = names.map(function(_nm, a) {
+          return new Float32Array(count * 3 * sizes[a]);
+        });
+        const w = names.map(function() {
+          return 0;
+        });
+        let wb = 0;
+        segs.forEach(function(seg) {
+          if (typeof seg[0] === "number") {
+            for (let a = 0; a < names.length; a++) {
+              const size = sizes[a];
+              if (!idx) {
+                dst[a].set(arrs[a].subarray(seg[0] * 3 * size, seg[1] * 3 * size), w[a]);
+                w[a] += (seg[1] - seg[0]) * 3 * size;
+                continue;
+              }
+              for (let f = seg[0] * 3; f < seg[1] * 3; f++) for (let q = 0; q < size; q++) dst[a][w[a]++] = arrs[a][idx[f] * size + q];
+            }
+            if (boxesOut2 && ti) {
+              boxesOut2.set(ti.boxes.subarray(seg[0] * 6, seg[1] * 6), wb);
+              wb += (seg[1] - seg[0]) * 6;
+            }
+            return;
+          }
+          seg.forEach(function(t) {
+            if (boxesOut2) {
+              for (let k = 0; k < 3; k++) {
+                boxesOut2[wb + k] = Math.fround(Math.min(t[0][k], t[1][k], t[2][k]));
+                boxesOut2[wb + 3 + k] = Math.fround(Math.max(t[0][k], t[1][k], t[2][k]));
+              }
+              wb += 6;
+            }
+            let off = 0;
+            for (let a = 0; a < names.length; a++) {
+              for (let k = 0; k < 3; k++) for (let q = 0; q < sizes[a]; q++) dst[a][w[a]++] = t[k][off + q];
+              off += sizes[a];
+            }
           });
-          g.setAttribute(nm, new THREE.BufferAttribute(arr, sizes[a]));
-          off += sizes[a];
+        });
+        names.forEach(function(nm, a) {
+          g.setAttribute(nm, new THREE.BufferAttribute(dst[a], sizes[a]));
         });
         g.userData.crease = true;
         return g;
       }
-      const out = { geo: build(tris), cut: {} };
+      const boxesOut = ti ? new Float64Array(total * 6) : void 0;
+      const out = { geo: fill(segments, total, boxesOut), cut: {}, tasks: {} };
+      if (boxesOut) storeTriIndex(out.geo, boxesOut);
       Object.keys(cut).forEach(function(k) {
-        out.cut[k] = crease(build(cut[k]), 42);
+        const piece = fill([cut[k]], cut[k].length);
+        const mode = tests.find(function(T) {
+          return T.tag === k;
+        }).pieces;
+        if (mode === "none") out.cut[k] = piece;
+        else if (mode === "later") {
+          out.cut[k] = piece;
+          out.tasks[k] = creaseTask(piece, 42);
+        } else out.cut[k] = crease(piece, 42);
       });
       return out;
     }
+    function refreshBounds(geo) {
+      const found = boundsFromIndex(geo);
+      if (!found) {
+        geo.computeBoundingSphere();
+        geo.computeBoundingBox();
+        return;
+      }
+      if (geo.boundingBox && geo.boundingSphere && boundsDone.get(geo) === found.version) return;
+      const b = found.box;
+      if (!geo.boundingBox) geo.boundingBox = new THREE.Box3();
+      geo.boundingBox.min.set(b[0], b[1], b[2]);
+      geo.boundingBox.max.set(b[3], b[4], b[5]);
+      if (!geo.boundingSphere) geo.boundingSphere = new THREE.Sphere();
+      const center = geo.boundingBox.getCenter(geo.boundingSphere.center);
+      const P = geo.attributes.position.array;
+      let maxRadiusSq = 0;
+      for (let i = 0; i < P.length; i += 3) {
+        const dx = center.x - P[i];
+        const dy = center.y - P[i + 1];
+        const dz = center.z - P[i + 2];
+        maxRadiusSq = Math.max(maxRadiusSq, dx * dx + dy * dy + dz * dz);
+      }
+      geo.boundingSphere.radius = Math.sqrt(maxRadiusSq);
+      boundsDone.set(geo, found.version);
+    }
+    const boundsDone = /* @__PURE__ */ new WeakMap();
     function mergeGeometries(list2) {
       const pos = [];
       const nor = [];
@@ -2954,7 +3256,7 @@ var GameVehicles = (() => {
         }
       };
     };
-    Object.assign(I, { roundedBoxGeometry, taper, subdivide, crease, pathShape, tumble, loftGeometry, hullGeometry, cutGeometry, mergeGeometries, uvProject });
+    Object.assign(I, { roundedBoxGeometry, taper, subdivide, crease, creaseTask, refreshBounds, pathShape, tumble, loftGeometry, hullGeometry, cutGeometry, mergeGeometries, uvProject });
   }
 
   // ../game-contracts/dist/index.js
@@ -6359,8 +6661,15 @@ var GameVehicles = (() => {
       x.arc(cx, cy, 26 * s, 0, PI * 2);
       x.fill();
     }
+    const NO_CANVAS = new Proxy(function() {
+    }, { get: () => NO_CANVAS, apply: () => NO_CANVAS, set: () => true });
     function crackGlass(c, msh, p, force, sc) {
       const G = msh.userData.glass;
+      if (G.cracksFreed) {
+        drawWeb(NO_CANVAS, 0, 0, sc != null ? sc : 0.6 + force * 0.5, Math.max(0.4, G.aspect || 1), c.rand);
+        G.hits++;
+        return;
+      }
       if (!G.cv) {
         G.cv = document2.createElement("canvas");
         G.cv.width = G.cv.height = 256;
@@ -6443,6 +6752,14 @@ var GameVehicles = (() => {
       const G = msh.userData.glass;
       if (G.broken) return;
       G.broken = true;
+      const freeCracks = function() {
+        if (!G.tex) return;
+        if (msh.material !== MATERIALS.glassEdge && msh.material?.map === G.tex) msh.material.dispose();
+        G.tex.dispose();
+        G.tex = null;
+        G.cv = null;
+        G.cracksFreed = true;
+      };
       const cubesAt = [];
       if (G.outline && G.T !== void 0) {
         const out = G.outline;
@@ -6476,6 +6793,7 @@ var GameVehicles = (() => {
         geo.computeVertexNormals();
         msh.geometry.dispose();
         msh.geometry = geo;
+        freeCracks();
         msh.material = MATERIALS.glassEdge;
         let minx = 1e9;
         let maxx = -1e9;
@@ -6499,8 +6817,12 @@ var GameVehicles = (() => {
         if (rim) {
           msh.geometry.dispose();
           msh.geometry = rim;
+          freeCracks();
           msh.material = MATERIALS.glassEdge;
-        } else msh.visible = false;
+        } else {
+          freeCracks();
+          msh.visible = false;
+        }
         for (let j = 0; j < 36; j++)
           cubesAt.push(
             new V3(
@@ -8335,6 +8657,8 @@ var GameVehicles = (() => {
       const pos = g && g.attributes && g.attributes.position;
       return o.raycast === THREE.Mesh.prototype.raycast && !o.isSkinnedMesh && !Array.isArray(o.material) && pos && !pos.isInterleavedBufferAttribute && pos.itemSize === 3 && !g.groups.length && !(g.morphAttributes && g.morphAttributes.position) && (g.index ? g.index.count : pos.count) / 3 >= PROXY_MIN_TRIANGLES;
     }
+    let _keep = new Uint32Array(0);
+    let _box = new Float32Array(0);
     function proxyIn(o, Mw, R) {
       _pm.copy(o.matrixWorld).invert().multiply(Mw);
       const lo = [Infinity, Infinity, Infinity];
@@ -8347,39 +8671,48 @@ var GameVehicles = (() => {
         }
       }
       const g = o.geometry;
-      const P = g.attributes.position.array;
+      const ti = triIndexOf(g);
+      if (!ti) return null;
       const ix = g.index ? g.index.array : null;
-      const n = ix ? ix.length : P.length / 3;
-      const keep = new Uint32Array(n - n % 3);
+      const boxes = ti.boxes;
+      const blocks = ti.blocks;
+      if (_keep.length < ti.triangles * 3) {
+        _keep = new Uint32Array(ti.triangles * 3);
+        _box = new Float32Array(ti.triangles * 6);
+      }
+      const keep = _keep;
+      const box2 = _box;
       let nk = 0;
-      for (let t = 0; t + 2 < n; t += 3) {
-        const a = (ix ? ix[t] : t) * 3;
-        const b = (ix ? ix[t + 1] : t + 1) * 3;
-        const d = (ix ? ix[t + 2] : t + 2) * 3;
-        let out = false;
-        for (let k = 0; k < 3 && !out; k++) {
-          const u = P[a + k];
-          const v = P[b + k];
-          const w = P[d + k];
-          out = Math.max(u, v, w) < lo[k] || Math.min(u, v, w) > hi[k];
-        }
-        if (!out) {
-          keep[nk++] = ix ? ix[t] : t;
-          keep[nk++] = ix ? ix[t + 1] : t + 1;
-          keep[nk++] = ix ? ix[t + 2] : t + 2;
+      let nt = 0;
+      for (let blk = 0, t0 = 0; t0 < ti.triangles; blk++, t0 += TRI_BLOCK) {
+        const j = blk * 6;
+        if (blocks[j + 3] < lo[0] || blocks[j] > hi[0] || blocks[j + 4] < lo[1] || blocks[j + 1] > hi[1] || blocks[j + 5] < lo[2] || blocks[j + 2] > hi[2]) continue;
+        const t1 = Math.min(ti.triangles, t0 + TRI_BLOCK);
+        for (let t = t0; t < t1; t++) {
+          const q = t * 6;
+          if (boxes[q + 3] < lo[0] || boxes[q] > hi[0] || boxes[q + 4] < lo[1] || boxes[q + 1] > hi[1] || boxes[q + 5] < lo[2] || boxes[q + 2] > hi[2]) continue;
+          keep[nk++] = ix ? ix[t * 3] : t * 3;
+          keep[nk++] = ix ? ix[t * 3 + 1] : t * 3 + 1;
+          keep[nk++] = ix ? ix[t * 3 + 2] : t * 3 + 2;
+          for (let k = 0; k < 6; k++) box2[nt * 6 + k] = boxes[q + k];
+          nt++;
         }
       }
       if (!nk) return null;
       const kept = keep.slice(0, nk);
-      const box2 = new Float32Array(kept.length / 3 * 6);
-      for (let t = 0, j = 0; t < kept.length; t += 3, j += 6) {
-        const a = kept[t] * 3;
-        const b = kept[t + 1] * 3;
-        const d = kept[t + 2] * 3;
+      const keptBox = box2.slice(0, nt * 6);
+      const keptBlocks = new Float32Array(Math.ceil(nt / TRI_BLOCK) * 6);
+      for (let blk = 0; blk * TRI_BLOCK < nt; blk++) {
+        const b = blk * 6;
         for (let k = 0; k < 3; k++) {
-          box2[j + k] = Math.min(P[a + k], P[b + k], P[d + k]);
-          box2[j + 3 + k] = Math.max(P[a + k], P[b + k], P[d + k]);
+          keptBlocks[b + k] = Infinity;
+          keptBlocks[b + 3 + k] = -Infinity;
         }
+        for (let t = blk * TRI_BLOCK, t1 = Math.min(nt, t + TRI_BLOCK); t < t1; t++)
+          for (let k = 0; k < 3; k++) {
+            if (keptBox[t * 6 + k] < keptBlocks[b + k]) keptBlocks[b + k] = keptBox[t * 6 + k];
+            if (keptBox[t * 6 + 3 + k] > keptBlocks[b + 3 + k]) keptBlocks[b + 3 + k] = keptBox[t * 6 + 3 + k];
+          }
       }
       const pg = new THREE.BufferGeometry();
       pg.setAttribute("position", g.attributes.position);
@@ -8390,7 +8723,8 @@ var GameVehicles = (() => {
       proxy.layers.mask = o.layers.mask;
       proxy.proxyOf = o;
       proxy.kept = kept;
-      proxy.keptBox = box2;
+      proxy.keptBox = keptBox;
+      proxy.keptBlocks = keptBlocks;
       return proxy;
     }
     function narrowTo(rc, proxy) {
@@ -8410,13 +8744,21 @@ var GameVehicles = (() => {
       const hi2 = Math.max(z0, _pv.z) + 1e-4;
       const K = proxy.kept;
       const X = proxy.keptBox;
+      const KB = proxy.keptBlocks;
+      const nt = K.length / 3;
       const dst = proxy.geometry.index.array;
       let m = 0;
-      for (let t = 0, j = 0; t < K.length; t += 3, j += 6) {
-        if (X[j + 3] < lo0 || X[j] > hi0 || X[j + 4] < lo1 || X[j + 1] > hi1 || X[j + 5] < lo2 || X[j + 2] > hi2) continue;
-        dst[m++] = K[t];
-        dst[m++] = K[t + 1];
-        dst[m++] = K[t + 2];
+      for (let blk = 0, t0 = 0; t0 < nt; blk++, t0 += TRI_BLOCK) {
+        const b = blk * 6;
+        if (KB[b + 3] < lo0 || KB[b] > hi0 || KB[b + 4] < lo1 || KB[b + 1] > hi1 || KB[b + 5] < lo2 || KB[b + 2] > hi2) continue;
+        const t1 = Math.min(nt, t0 + TRI_BLOCK);
+        for (let t = t0; t < t1; t++) {
+          const j = t * 6;
+          if (X[j + 3] < lo0 || X[j] > hi0 || X[j + 4] < lo1 || X[j + 1] > hi1 || X[j + 5] < lo2 || X[j + 2] > hi2) continue;
+          dst[m++] = K[t * 3];
+          dst[m++] = K[t * 3 + 1];
+          dst[m++] = K[t * 3 + 2];
+        }
       }
       proxy.geometry.setDrawRange(0, m);
     }
@@ -8834,6 +9176,8 @@ var GameVehicles = (() => {
         irel.copy(rel).invert();
         const pos = g.attributes.position;
         let changed = false;
+        const liveIndex = liveTriIndex(g);
+        const movedVertices = [];
         const near = boxInFrame(B, irel, v);
         for (let i = 0; i < pos.count; i++) {
           v.fromBufferAttribute(pos, i);
@@ -8845,6 +9189,7 @@ var GameVehicles = (() => {
           if (opt.extra) opt.extra(v, f);
           v.applyMatrix4(irel);
           pos.setXYZ(i, v.x, v.y, v.z);
+          movedVertices.push(i);
           changed = true;
         }
         if (opt.extraAll) {
@@ -8853,12 +9198,14 @@ var GameVehicles = (() => {
             if (opt.extraAll(v)) {
               v.applyMatrix4(irel);
               pos.setXYZ(j, v.x, v.y, v.z);
+              movedVertices.push(j);
               changed = true;
             }
           }
         }
         if (changed) {
           pos.needsUpdate = true;
+          if (liveIndex) touchTriIndex(g, liveIndex, movedVertices);
           dirty.add(msh);
         }
         if (changed || boundsDue) {
@@ -8889,6 +9236,26 @@ var GameVehicles = (() => {
       });
       return { field, moved, ax, a, cu, cv, hu, hv, outer };
     }
+    function panelBoundsIn(rel, rect, B, a, ax) {
+      const det = rel.determinant();
+      if (!Number.isFinite(det) || Math.abs(det) < 1e-12) return void 0;
+      const back = rel.clone().invert();
+      const lo = [Infinity, Infinity, Infinity];
+      const hi = [-Infinity, -Infinity, -Infinity];
+      const q = new V3();
+      for (let i = 0; i < 8; i++) {
+        q.setComponent(ax[0], i & 1 ? rect[1] : rect[0]);
+        q.setComponent(ax[1], i & 2 ? rect[3] : rect[2]);
+        q.setComponent(a, i & 4 ? I.boxHi(B, a) : I.boxLo(B, a));
+        q.applyMatrix4(back);
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], q.getComponent(k));
+          hi[k] = Math.max(hi[k], q.getComponent(k));
+        }
+      }
+      const pad = 1e-3;
+      return { lo: lo.map((x) => x - pad), hi: hi.map((x) => x + pad) };
+    }
     function cutPanel(c, z, rect, keep, dirty, o) {
       o = o || {};
       const B = z.box;
@@ -8921,6 +9288,7 @@ var GameVehicles = (() => {
         }
         const test = {
           tag: "part",
+          pieces: keep ? o.pieceTasks ? "later" : "crease" : "none",
           sel: o.anyN || z.cutAll ? null : function(n) {
             nv.copy(n).applyMatrix3(nm).normalize();
             return nv.dot(outN) > 0.3;
@@ -8939,13 +9307,12 @@ var GameVehicles = (() => {
             return q;
           }
         };
-        const r = cutGeometry(g, [test]);
+        const r = cutGeometry(g, [{ ...test, bounds: panelBoundsIn(rel, rect, B, a, ax) }]);
         const cg = r.cut.part;
         if (!cg || !cg.attributes.position.count) return;
         g.dispose();
         msh.geometry = r.geo;
-        r.geo.computeBoundingSphere();
-        r.geo.computeBoundingBox();
+        I.refreshBounds(r.geo);
         dirty.add(msh);
         if (!keep) {
           cg.dispose();
@@ -8958,6 +9325,7 @@ var GameVehicles = (() => {
         rel.decompose(pm.position, pm.quaternion, pm.scale);
         c.vehicle.add(pm);
         pm.updateMatrixWorld(true);
+        if (o.pieceTasks) o.pieceTasks.set(pm, r.tasks.part);
         pieces.push({ mesh: pm, cut: true });
       });
       return pieces;
@@ -12594,7 +12962,15 @@ var GameVehicles = (() => {
       __publicField(this, "gone", /* @__PURE__ */ new Set());
       /** Shows or hides the plate and the recess of a door or lid by its state (see `showWhenOpen`). */
       __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());
       __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);
+      /** 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");
       this.kit = kit;
       this.c = c;
@@ -12604,6 +12980,8 @@ var GameVehicles = (() => {
       for (const p of model.parts) this.byId.set(p.id, p);
       c.root.updateMatrixWorld(true);
       this.hood = this.nameHood();
+      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) {
         if (p.role === "door" || p.role === "lid") this.makePlate(p);
         else if (p.role === "mirror" && !this.mirrorObjects(p).length) this.makeMirror(p);
@@ -12739,11 +13117,21 @@ var GameVehicles = (() => {
      * keeps the shape of its model instead of flat panels over its curved sides. Follows the hinge's rotation, whoever turns it (the clips of a host, `detach`).
      */
     showWhenOpen(id, piv, panel, recess) {
+      let busy = false;
       const sync = () => {
+        if (busy) return;
         const r = piv.rotation;
         const open = Math.abs(r.x) + Math.abs(r.y) + Math.abs(r.z) > 1e-3 || this.gone.has(id) || piv.parent !== this.c.vehicle;
-        panel.visible = open;
-        recess.visible = open;
+        if (open && !this.gone.has(id) && piv.parent === this.c.vehicle && !this.skins.has(id)) {
+          busy = true;
+          try {
+            this.skins.set(id, this.takeSkin(id, piv));
+          } finally {
+            busy = false;
+          }
+        }
+        panel.visible = open && !this.skins.get(id);
+        recess.visible = open && !this.skins.get(id);
       };
       const euler = piv.rotation;
       const quaternion = piv.quaternion;
@@ -12760,6 +13148,58 @@ var GameVehicles = (() => {
       this.syncPlates.set(id, sync);
       sync();
     }
+    /**
+     * Cuts the skin of a door or lid zone out of the body (as the damage's hanging door does) and hangs it, with the thin parts on it (trim, handle) and, for a door, the side
+     * window over it, on the hinge. Done with the hinge closed, so every piece keeps its place; answers whether there was skin to take.
+     */
+    takeSkin(id, piv) {
+      const p = this.byId.get(id);
+      const z = p && this.zone(p);
+      if (!p || !z) return false;
+      const I = this.I;
+      const B = z.box;
+      const q = piv.quaternion.clone();
+      piv.quaternion.identity();
+      this.c.root.updateMatrixWorld(true);
+      const inv = I.worldInverseOf(this.c);
+      let objs = [];
+      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);
+          this.mend(dirty);
+          if (pcs.length) objs = [...pcs, ...I.followersIn(this.c, z, inv), ...I.windowsOver(this.c, z, inv)];
+        } else {
+          const pcs = this.cutZone(z);
+          if (pcs.length) objs = [...pcs, ...I.followersIn(this.c, z, inv)];
+        }
+      } catch {
+        objs = [];
+      }
+      const deform = this.c.deform ?? [];
+      for (const o of objs) {
+        if (!o.parent || o === piv) continue;
+        piv.attach(o);
+        o.traverse((x) => {
+          x.userData.noFollow = true;
+        });
+        const di = deform.indexOf(o);
+        if (di >= 0) deform.splice(di, 1);
+      }
+      piv.quaternion.copy(q);
+      this.c.root.updateMatrixWorld(true);
+      return objs.length > 0;
+    }
+    mend(dirty) {
+      dirty.forEach((msh) => {
+        const g = msh.geometry;
+        if (g.userData.crease || !g.index) this.I.crease(g, 42);
+        else g.computeVertexNormals();
+        g.computeBoundingSphere();
+        g.computeBoundingBox();
+      });
+    }
     makeMirror(p) {
       const [cx, cy, cz] = p.box.center;
       const s = cz < 0 ? -1 : 1;
@@ -12897,6 +13337,31 @@ var GameVehicles = (() => {
         this.I.flattenTire(w, Math.min(0.5, 0.12 + 0.38 * melt));
       }
     }
+    /** Smooths the normals of a cut mesh a slice per frame (see `pump`); until then it draws with flat face normals. */
+    smoothLater(msh) {
+      this.smoothing.set(msh, this.I.creaseTask(msh.geometry, 42));
+      this.tornThisFrame = true;
+    }
+    /** Spends at most `budgetMs` finishing the pending normal smoothing. Call once per frame. */
+    pump(budgetMs = 2.5) {
+      if (this.tornThisFrame) {
+        this.tornThisFrame = false;
+        return;
+      }
+      if (!this.smoothing.size && !this.warming) return;
+      const deadline = performance.now() + budgetMs;
+      for (const [msh, task] of this.smoothing) {
+        if (msh.geometry !== task.geo || task.step(deadline)) this.smoothing.delete(msh);
+        if (performance.now() >= deadline) return;
+      }
+      this.warmIndexes(deadline);
+    }
+    /** 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;
+      this.warming = this.warming.filter((msh) => !warmTriIndex(msh.geometry, deadline));
+      if (!this.warming.length) this.warming = null;
+    }
     /** Moves the panel of a lost zone out of the body (the kit's torn-off look). */
     tearOff(p) {
       const z = this.zone(p);
@@ -12909,10 +13374,9 @@ var GameVehicles = (() => {
       }
       dirty.forEach((msh) => {
         const g = msh.geometry;
-        if (g.userData.crease || !g.index) this.I.crease(g, 42);
+        if (g.userData.crease || !g.index) this.smoothLater(msh);
         else g.computeVertexNormals();
-        g.computeBoundingSphere();
-        g.computeBoundingBox();
+        this.I.refreshBounds(g);
       });
       this.gone.add(p.id);
     }
@@ -13055,17 +13519,19 @@ var GameVehicles = (() => {
       const mg = Math.min(0.05, (u1 - u0) * 0.08, (v1 - v0) * 0.08);
       const dirty = /* @__PURE__ */ new Set();
       let pcs = [];
+      const pieceTasks = /* @__PURE__ */ new Map();
       try {
-        pcs = I.cutPanel(this.c, z, [u0 + mg, u1 - mg, v0 + mg, v1 - mg], true, dirty);
+        pcs = I.cutPanel(this.c, z, [u0 + mg, u1 - mg, v0 + mg, v1 - mg], true, dirty, { pieceTasks });
       } catch {
         pcs = [];
       }
+      pieceTasks.forEach((task, mesh2) => this.smoothing.set(mesh2, task));
+      this.tornThisFrame = true;
       dirty.forEach((msh) => {
         const g = msh.geometry;
-        if (g.userData.crease || !g.index) I.crease(g, 42);
+        if (g.userData.crease || !g.index) this.smoothLater(msh);
         else g.computeVertexNormals();
-        g.computeBoundingSphere();
-        g.computeBoundingBox();
+        I.refreshBounds(g);
       });
       return pcs.map((q) => q.mesh).filter((m) => !!m);
     }
@@ -13844,7 +14310,7 @@ var GameVehicles = (() => {
       specCache = { name: options.name ?? c.spec.name ?? c.key, parts, joints, tags: ["vehicle", kindOf(c)] };
       return specCache;
     };
-    const state = () => {
+    const buildState = () => {
       const parts = model.parts.map((d) => {
         const p = ps.get(d.id);
         const marked = p.dents.length > 0 || p.holes.length > 0 || p.cracks.length > 0;
@@ -13881,7 +14347,15 @@ var GameVehicles = (() => {
       }));
       return { id, name: options.name ?? c.spec.name ?? c.key, position: [0, 0, 0], rotation: [0, 0, 0, 1], parts, joints, groups: groupsCache.map((g) => [...g]), destroyed: parts.every((p) => p.status === "broken" || p.status === "melted" || p.status === "ashes") };
     };
+    let stateCache;
+    const state = () => stateCache ?? (stateCache = buildState());
+    const isSimulating = () => {
+      if (leaks.size > 0) return true;
+      for (const p of ps.values()) if (!p.lost && (p.burning || p.temp > AMBIENT)) return true;
+      return false;
+    };
     const hit = (h) => {
+      stateCache = void 0;
       const out = [];
       const hh = h.space === "local" ? { ...h, space: "world", point: toWorld(h.point) } : h;
       if (hh.space === "local" || !hh.point) return out;
@@ -13908,6 +14382,8 @@ var GameVehicles = (() => {
       clock += dt;
       const out = queue;
       queue = [];
+      const wasSimulating = isSimulating();
+      const handledBefore = (blastHandled ? 1 : 0) + (rollHandled ? 2 : 0);
       const hood = c.hood;
       if (hood) {
         const sign2 = hood.sign || 1;
@@ -13928,12 +14404,15 @@ var GameVehicles = (() => {
       afterBlast(out);
       afterRoll(out);
       applyEffects();
+      vis?.pump();
+      if (wasSimulating || out.length > 0 || handledBefore !== (blastHandled ? 1 : 0) + (rollHandled ? 2 : 0)) stateCache = void 0;
       return out;
     };
     const disassemble = (jointId, tool, dt) => {
       const j = js.find((x) => x.def.id === jointId);
       if (!j || !j.def.tools.includes(tool)) return -1;
       if (j.open) return 1;
+      stateCache = void 0;
       j.progress = Math.min(1, j.progress + dt / j.def.seconds);
       const step = Math.floor(j.progress * 4) / 4;
       if (step > j.reported && j.progress < 1) {
@@ -13949,6 +14428,7 @@ var GameVehicles = (() => {
       return j.progress;
     };
     const extinguish = (partId) => {
+      stateCache = void 0;
       for (const p of ps.values()) {
         if (partId && p.def.id !== partId) continue;
         if (p.burning) {
@@ -13962,6 +14442,7 @@ var GameVehicles = (() => {
       }
     };
     const reset = () => {
+      stateCache = void 0;
       const old = c;
       const parent = old.root.parent;
       const next = kit.build(old.key, old.state, old.scenario != null ? { scenario: old.scenario } : void 0);
@@ -13979,6 +14460,7 @@ var GameVehicles = (() => {
       setup();
     };
     const rollover = (side2 = 1) => {
+      stateCache = void 0;
       if (kit.roll(c, side2)) rolled = true;
       void rolled;
     };