ldr 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,4 +1,4 @@
-// src/spec.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/spec.ts
 var norm = (s) => s.trim().toLowerCase().replace(/\\/g, "/").replace(/\/+/g, "/");
 function parseColor(tok) {
   if (/^0x/i.test(tok))
@@ -647,7 +647,7 @@ function fileStepViews(f) {
   viewMemo.set(f, out);
   return out;
 }
-// src/model.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/model.ts
 function flatten(doc, opts = {}) {
   const out = [];
   const maxDepth = opts.maxDepth ?? 64;
@@ -768,7 +768,7 @@ function parseLDConfig(text) {
   }
   return out;
 }
-// src/render.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/render.ts
 import * as THREE from "three";
 async function loadPack(url) {
   const res = await fetch(url);
@@ -796,19 +796,60 @@ function decodePack(buf) {
   const header = JSON.parse(new TextDecoder().decode(new Uint8Array(buf, 4, hl)));
   const base = 4 + hl;
   const arr = (r) => r && (r[2] === "f32" ? new Float32Array(buf, base + r[0], r[1]) : r[2] === "u16" ? new Uint16Array(buf, base + r[0], r[1]) : r[2] === "u8" ? new Uint8Array(buf, base + r[0], r[1]) : new Uint32Array(buf, base + r[0], r[1]));
-  return { header, arr, bytes: buf.byteLength };
+  return { header, arr, bytes: buf.byteLength, buffer: buf };
 }
-function geom(b, arr) {
+var toI8 = (a) => {
+  const o = new Int8Array(a.length);
+  for (let i = 0;i < a.length; i++)
+    o[i] = Math.round(Math.max(-1, Math.min(1, a[i])) * 127);
+  return o;
+};
+var toU8 = (a) => {
+  const o = new Uint8Array(a.length);
+  for (let i = 0;i < a.length; i++)
+    o[i] = Math.round(Math.max(0, Math.min(1, a[i])) * 255);
+  return o;
+};
+function flatNormals(pos, idx) {
+  const n = new Float32Array(pos.length);
+  for (let t = 0;t < idx.length; t += 3) {
+    const a = idx[t] * 3, b = idx[t + 1] * 3, c = idx[t + 2] * 3;
+    const ux = pos[b] - pos[a], uy = pos[b + 1] - pos[a + 1], uz = pos[b + 2] - pos[a + 2], vx = pos[c] - pos[a], vy = pos[c + 1] - pos[a + 1], vz = pos[c + 2] - pos[a + 2];
+    let nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+    const l = Math.hypot(nx, ny, nz) || 1;
+    nx /= l;
+    ny /= l;
+    nz /= l;
+    for (const o of [a, b, c]) {
+      n[o] = nx;
+      n[o + 1] = ny;
+      n[o + 2] = nz;
+    }
+  }
+  return n;
+}
+var geomCache = new WeakMap;
+function geom(b, arr, quant = true) {
   if (!b)
     return null;
-  const g = new THREE.BufferGeometry;
+  let c = geomCache.get(arr);
+  if (!c)
+    geomCache.set(arr, c = new Map);
+  const ck = quant ? b : b.pos;
+  let g = c.get(ck);
+  if (g)
+    return g;
+  g = new THREE.BufferGeometry;
   g.setAttribute("position", new THREE.BufferAttribute(arr(b.pos), 3));
-  g.setAttribute("normal", new THREE.BufferAttribute(arr(b.nrm), 3));
-  g.setAttribute("ldrColor", new THREE.BufferAttribute(arr(b.col), 4));
+  const nrm = b.nrm ? arr(b.nrm) : flatNormals(arr(b.pos), arr(b.idx));
+  const col = arr(b.col);
+  g.setAttribute("normal", quant ? new THREE.BufferAttribute(toI8(nrm), 3, true) : new THREE.BufferAttribute(nrm, 3));
+  g.setAttribute("ldrColor", col instanceof Uint8Array ? new THREE.BufferAttribute(col, 4, true) : quant ? new THREE.BufferAttribute(toU8(col), 4, true) : new THREE.BufferAttribute(col, 4));
   if (b.idx)
     g.setIndex(new THREE.BufferAttribute(arr(b.idx), 1));
   if (b.uv)
     g.setAttribute("ldrUV", new THREE.BufferAttribute(arr(b.uv), 2));
+  c.set(ck, g);
   return g;
 }
 function makeMaterial(side) {
@@ -1012,120 +1053,544 @@ function instancedLines(pos, mats, count) {
   l.frustumCulled = false;
   return l;
 }
-var toM4 = (m, o = 0) => new THREE.Matrix4().set(m[o + 3], m[o + 4], m[o + 5], m[o], m[o + 6], m[o + 7], m[o + 8], m[o + 1], m[o + 9], m[o + 10], m[o + 11], m[o + 2], 0, 0, 0, 1);
-var mul12 = (a, b) => {
-  const r = (i, j) => a[3 + i * 3] * b[3 + j] + a[4 + i * 3] * b[6 + j] + a[5 + i * 3] * b[9 + j];
-  return [a[0] + a[3] * b[0] + a[4] * b[1] + a[5] * b[2], a[1] + a[6] * b[0] + a[7] * b[1] + a[8] * b[2], a[2] + a[9] * b[0] + a[10] * b[1] + a[11] * b[2], r(0, 0), r(0, 1), r(0, 2), r(1, 0), r(1, 1), r(1, 2), r(2, 0), r(2, 1), r(2, 2)];
+function writeM4(t, o, m, mo = 0) {
+  t[o] = m[mo + 3];
+  t[o + 1] = m[mo + 6];
+  t[o + 2] = m[mo + 9];
+  t[o + 3] = 0;
+  t[o + 4] = m[mo + 4];
+  t[o + 5] = m[mo + 7];
+  t[o + 6] = m[mo + 10];
+  t[o + 7] = 0;
+  t[o + 8] = m[mo + 5];
+  t[o + 9] = m[mo + 8];
+  t[o + 10] = m[mo + 11];
+  t[o + 11] = 0;
+  t[o + 12] = m[mo];
+  t[o + 13] = m[mo + 1];
+  t[o + 14] = m[mo + 2];
+  t[o + 15] = 1;
+}
+function newIM(g, mat, n) {
+  const im = new THREE.InstancedMesh(g, mat, 0);
+  im.instanceMatrix = new THREE.InstancedBufferAttribute(new Float32Array(n * 16), 16);
+  im.count = n;
+  return im;
+}
+function fillInstances(im, ids, insts, color) {
+  const M = im.instanceMatrix.array;
+  const C = new Float32Array(ids.length * 3);
+  for (let k = 0;k < ids.length; k++) {
+    const it = insts[ids[k]];
+    writeM4(M, k * 16, it.m);
+    color(it.color).toArray(C, k * 3);
+  }
+  im.instanceColor = new THREE.InstancedBufferAttribute(C, 3);
+}
+var upright = (m, o = 0) => Math.abs(m[o + 7] - 1) < 0.001 && Math.abs(m[o + 4]) < 0.001 && Math.abs(m[o + 10]) < 0.001;
+var prepCache = new WeakMap;
+function prepPart(H, part) {
+  let c = prepCache.get(H);
+  if (!c)
+    prepCache.set(H, c = new Map);
+  let r = c.get(part);
+  if (r !== undefined)
+    return r;
+  const p = H.parts[part];
+  if (!p) {
+    c.set(part, null);
+    return null;
+  }
+  const n = p.studs.length;
+  const studM = new Float64Array(n * 12);
+  const kind = [], color = [];
+  p.studs.forEach((s, i) => {
+    kind.push(s[0]);
+    color.push(s[1]);
+    for (let k = 0;k < 12; k++)
+      studM[i * 12 + k] = s[2 + k];
+  });
+  let mask = null, nx = 0, nz = 0;
+  if (p.mask) {
+    nx = p.mask[0];
+    nz = p.mask[1];
+    const bits = p.mask[2];
+    mask = new Uint8Array(bits.length);
+    for (let i = 0;i < bits.length; i++)
+      mask[i] = bits.charCodeAt(i) === 49 ? 1 : 0;
+  }
+  c.set(part, r = { nStuds: n, studM, kind, color, mask, nx, nz });
+  return r;
+}
+function mul12To(a, b, bo, w, ao = 0) {
+  const b0 = b[bo], b1 = b[bo + 1], b2 = b[bo + 2];
+  w[0] = a[ao] + a[ao + 3] * b0 + a[ao + 4] * b1 + a[ao + 5] * b2;
+  w[1] = a[ao + 1] + a[ao + 6] * b0 + a[ao + 7] * b1 + a[ao + 8] * b2;
+  w[2] = a[ao + 2] + a[ao + 9] * b0 + a[ao + 10] * b1 + a[ao + 11] * b2;
+  for (let i = 0;i < 3; i++)
+    for (let j = 0;j < 3; j++)
+      w[3 + i * 3 + j] = a[ao + 3 + i * 3] * b[bo + 3 + j] + a[ao + 4 + i * 3] * b[bo + 6 + j] + a[ao + 5 + i * 3] * b[bo + 9 + j];
+}
+var det12 = (m) => m[3] * (m[7] * m[11] - m[8] * m[10]) - m[4] * (m[6] * m[11] - m[8] * m[9]) + m[5] * (m[6] * m[10] - m[7] * m[9]);
+var cellKey = (lv2, cx, cz) => lv2 < -1048576 || lv2 >= 1048576 || cx < -32768 || cx >= 32768 || cz < -32768 || cz >= 32768 ? -1 : (lv2 + 1048576) * 4294967296 + (cx + 32768) * 65536 + (cz + 32768);
+var topKey = (x, y, z) => {
+  const rx = Math.round(x), ry = Math.round(y), rz = Math.round(z);
+  return rx < -131072 || rx >= 131072 || ry < -65536 || ry >= 65536 || rz < -131072 || rz >= 131072 ? -1 : (rx + 131072) * 34359738368 + (ry + 65536) * 262144 + (rz + 131072);
 };
-function computeCulling(insts, H) {
-  const upright = (m) => Math.abs(m[7] - 1) < 0.001 && Math.abs(m[4]) < 0.001 && Math.abs(m[10]) < 0.001;
+
+class NumTable {
+  keys;
+  vals;
+  mask;
+  size = 0;
+  constructor(cap = 1024) {
+    let n = 1024;
+    while (n < cap * 2)
+      n *= 2;
+    this.keys = new Float64Array(n).fill(-1);
+    this.vals = new Int32Array(n);
+    this.mask = n - 1;
+  }
+  slot(k) {
+    const lo = k >>> 0, hi = k / 4294967296 >>> 0;
+    let h = Math.imul(lo ^ Math.imul(hi, 2654435761), 2246822507);
+    h ^= h >>> 15;
+    return h & this.mask;
+  }
+  get(k) {
+    const K = this.keys;
+    let i = this.slot(k);
+    for (;; ) {
+      const x = K[i];
+      if (x === k)
+        return this.vals[i];
+      if (x === -1)
+        return -1;
+      i = i + 1 & this.mask;
+    }
+  }
+  put(k, v) {
+    if ((this.size + 1) * 2 > this.keys.length)
+      this.grow();
+    const K = this.keys;
+    let i = this.slot(k);
+    for (;; ) {
+      const x = K[i];
+      if (x === k) {
+        const o = this.vals[i];
+        this.vals[i] = v;
+        return o;
+      }
+      if (x === -1) {
+        K[i] = k;
+        this.vals[i] = v;
+        this.size++;
+        return -1;
+      }
+      i = i + 1 & this.mask;
+    }
+  }
+  grow() {
+    const ok = this.keys, ov = this.vals;
+    const n = ok.length * 2;
+    this.keys = new Float64Array(n).fill(-1);
+    this.vals = new Int32Array(n);
+    this.mask = n - 1;
+    this.size = 0;
+    for (let i = 0;i < ok.length; i++)
+      if (ok[i] !== -1)
+        this.put(ok[i], ov[i]);
+  }
+}
+var STEP_NEVER = 2147483647;
+function forEachStud(insts, H, fn) {
+  const w = new Float64Array(12);
+  let j = 0;
+  for (let idx = 0;idx < insts.length; idx++) {
+    const it = insts[idx];
+    const pp = prepPart(H, it.part);
+    if (!pp)
+      continue;
+    for (let s = 0;s < pp.nStuds; s++) {
+      mul12To(it.m, pp.studM, s * 12, w);
+      const c = pp.color[s];
+      fn(j++, idx, w, pp.kind[s], c === "16" ? it.color : c, s);
+    }
+  }
+}
+function cullCore(insts, H, steps) {
   const CELL = 40;
-  const rects = new Map;
-  const lk = (y) => Math.round(y * 2) / 2;
-  insts.forEach((it, idx) => {
+  const rx0 = [], rx1 = [], rz0 = [], rz1 = [], rInst = [], rPrep = [], rBx = [], rBz = [];
+  const cells = new NumTable(insts.length * 2);
+  const nextE = [], rectE = [];
+  for (let idx = 0;idx < insts.length; idx++) {
+    const it = insts[idx];
+    const m = it.m;
     const p = H.parts[it.part];
-    if (!p || !p.mask || !upright(it.m))
-      return;
+    if (!p || !p.mask || !upright(m))
+      continue;
     const b = p.bbox;
-    const xs = [], zs = [];
-    for (const x of [b[0], b[3]])
-      for (const z of [b[2], b[5]]) {
-        const w = [it.m[0] + it.m[3] * x + it.m[5] * z, it.m[2] + it.m[9] * x + it.m[11] * z];
-        xs.push(w[0]);
-        zs.push(w[1]);
+    let x0 = Infinity, x1 = -Infinity, z0 = Infinity, z1 = -Infinity;
+    for (let cxi = 0;cxi < 2; cxi++)
+      for (let czi = 0;czi < 2; czi++) {
+        const x = cxi ? b[3] : b[0], z = czi ? b[5] : b[2];
+        const wx = m[0] + m[3] * x + m[5] * z, wz = m[2] + m[9] * x + m[11] * z;
+        if (wx < x0)
+          x0 = wx;
+        if (wx > x1)
+          x1 = wx;
+        if (wz < z0)
+          z0 = wz;
+        if (wz > z1)
+          z1 = wz;
       }
-    const r = [Math.min(...xs), Math.max(...xs), Math.min(...zs), Math.max(...zs), idx];
-    const lv = lk(it.m[1] + b[4]);
-    for (let cx = Math.floor(r[0] / CELL);cx <= Math.floor(r[1] / CELL); cx++)
-      for (let cz = Math.floor(r[2] / CELL);cz <= Math.floor(r[3] / CELL); cz++) {
-        const k = lv + "|" + cx + "|" + cz;
-        (rects.get(k) || rects.set(k, []).get(k)).push(r);
+    const ri = rInst.length;
+    rx0.push(x0);
+    rx1.push(x1);
+    rz0.push(z0);
+    rz1.push(z1);
+    rInst.push(idx);
+    rPrep.push(prepPart(H, it.part));
+    rBx.push(b[0]);
+    rBz.push(b[2]);
+    const lv2 = Math.round((m[1] + b[4]) * 2);
+    for (let cx = Math.floor(x0 / CELL);cx <= Math.floor(x1 / CELL); cx++)
+      for (let cz = Math.floor(z0 / CELL);cz <= Math.floor(z1 / CELL); cz++) {
+        const k = cellKey(lv2, cx, cz);
+        if (k < 0)
+          continue;
+        const e = rectE.length;
+        rectE.push(ri);
+        nextE.push(cells.put(k, e));
       }
-  });
-  const covered = (x, y, z, self) => {
-    const list = rects.get(lk(y) + "|" + Math.floor(x / CELL) + "|" + Math.floor(z / CELL));
-    if (!list)
-      return false;
-    for (const r of list) {
-      if (r[4] === self || !(x - 6 >= r[0] - 0.5 && x + 6 <= r[1] + 0.5 && z - 6 >= r[2] - 0.5 && z + 6 <= r[3] + 0.5))
+  }
+  const SX = [0, 5, -5, 5, -5], SZ = [0, 5, 5, -5, -5];
+  const coverStep = (x, y, z, self) => {
+    const k = cellKey(Math.round(y * 2), Math.floor(x / CELL), Math.floor(z / CELL));
+    if (k < 0)
+      return STEP_NEVER;
+    let best = STEP_NEVER;
+    for (let e = cells.get(k);e >= 0; e = nextE[e]) {
+      const ri = rectE[e];
+      if (rInst[ri] === self || !(x - 6 >= rx0[ri] - 0.5 && x + 6 <= rx1[ri] + 0.5 && z - 6 >= rz0[ri] - 0.5 && z + 6 <= rz1[ri] + 0.5))
         continue;
-      const it = insts[r[4]];
-      const p = H.parts[it.part];
-      const m = it.m;
+      const m = insts[rInst[ri]].m;
+      const pp = rPrep[ri];
+      const bx = rBx[ri], bz = rBz[ri];
       const dx = x - m[0], dy = y - m[1], dz = z - m[2];
       const lx = m[3] * dx + m[6] * dy + m[9] * dz, lz = m[5] * dx + m[8] * dy + m[11] * dz;
-      const [nx, nz, bits] = p.mask;
+      const { nx, nz, mask: bits } = pp;
       let ok = true;
-      for (const [ox, oz] of [[0, 0], [5, 5], [-5, 5], [5, -5], [-5, -5]]) {
-        const ca = Math.floor((lx + ox - p.bbox[0]) / 20), cb = Math.floor((lz + oz - p.bbox[2]) / 20);
-        if (ca < 0 || cb < 0 || ca >= nx || cb >= nz || bits[ca * nz + cb] !== "1") {
+      for (let s = 0;s < 5; s++) {
+        const ca = Math.floor((lx + SX[s] - bx) / 20), cb = Math.floor((lz + SZ[s] - bz) / 20);
+        if (ca < 0 || cb < 0 || ca >= nx || cb >= nz || bits[ca * nz + cb] !== 1) {
           ok = false;
           break;
         }
       }
-      if (ok)
-        return true;
+      if (ok) {
+        if (!steps)
+          return 0;
+        const st = steps[rInst[ri]];
+        if (st < best)
+          best = st;
+      }
     }
-    return false;
+    return best;
   };
-  const studs = [];
-  const studTops = new Set;
-  const key3 = (x, y, z) => `${Math.round(x)},${Math.round(y)},${Math.round(z)}`;
-  insts.forEach((it, idx) => {
-    const p = H.parts[it.part];
-    if (!p)
+  let nStuds = 0;
+  for (const it of insts) {
+    const pp = prepPart(H, it.part);
+    if (pp)
+      nStuds += pp.nStuds;
+  }
+  const studHidden = new Uint8Array(nStuds), studUp = new Uint8Array(nStuds);
+  const tops = new NumTable(nStuds);
+  let studsHidden = 0;
+  const studHideStep = steps ? new Int32Array(nStuds).fill(STEP_NEVER) : undefined;
+  forEachStud(insts, H, (j, idx, w) => {
+    if (!upright(w))
       return;
-    for (const s of p.studs) {
-      const w = mul12(it.m, s.slice(2));
-      const color = s[1] === "16" ? it.color : s[1];
-      const up = upright(w);
-      studs.push({ kind: s[0], color, w, hidden: up && covered(w[0], w[1], w[2], idx) });
-      if (up)
-        studTops.add(key3(w[0], w[1], w[2]));
+    studUp[j] = 1;
+    const cs = coverStep(w[0], w[1], w[2], idx);
+    if (cs !== STEP_NEVER) {
+      studHidden[j] = 1;
+      studsHidden++;
+      if (studHideStep)
+        studHideStep[j] = cs;
     }
+    const k = topKey(w[0], w[1], w[2]);
+    if (k < 0)
+      return;
+    if (!steps) {
+      tops.put(k, 1);
+      return;
+    }
+    const st = steps[idx], o = tops.get(k);
+    if (o < 0 || st < o)
+      tops.put(k, st);
   });
-  const underHidden = insts.map((it) => {
+  const underHidden = new Uint8Array(insts.length);
+  const underHideStep = steps ? new Int32Array(insts.length).fill(STEP_NEVER) : undefined;
+  for (let idx = 0;idx < insts.length; idx++) {
+    const it = insts[idx];
     const p = H.parts[it.part];
     if (!p || !p.under || !upright(it.m))
-      return false;
+      continue;
     const b = p.bbox;
     const nx = Math.round((b[3] - b[0]) / 20), nz = Math.round((b[5] - b[2]) / 20);
     if (!nx || !nz || nx * nz > 4096)
-      return false;
-    for (let a = 0;a < nx; a++)
+      continue;
+    const m = it.m;
+    let all = true, at = 0;
+    for (let a = 0;a < nx && all; a++)
       for (let c = 0;c < nz; c++) {
         const lx = b[0] + 10 + 20 * a, lz = b[2] + 10 + 20 * c;
-        const x = it.m[0] + it.m[3] * lx + it.m[5] * lz, z = it.m[2] + it.m[9] * lx + it.m[11] * lz;
-        if (!studTops.has(key3(x, it.m[1] + b[4], z)))
-          return false;
+        const x = m[0] + m[3] * lx + m[5] * lz, z = m[2] + m[9] * lx + m[11] * lz;
+        const k = topKey(x, m[1] + b[4], z);
+        const t = k < 0 ? -1 : tops.get(k);
+        if (t < 0) {
+          all = false;
+          break;
+        }
+        if (t > at)
+          at = t;
       }
-    return true;
+    if (all) {
+      underHidden[idx] = 1;
+      if (underHideStep)
+        underHideStep[idx] = at;
+    }
+  }
+  return { nStuds, studHidden, studUp, underHidden, studsHidden, studHideStep, underHideStep };
+}
+function computeCulling(insts, H) {
+  const c = cullCore(insts, H);
+  const studs = new Array(c.nStuds);
+  forEachStud(insts, H, (j, _i, w, kind, color) => {
+    studs[j] = { kind, color, w: Array.from(w), hidden: c.studHidden[j] === 1 };
   });
-  return { studs, underHidden };
+  return { studs, underHidden: Array.from(c.underHidden, (x) => x === 1) };
+}
+function gridClusters(n, x, z, k) {
+  if (n <= k || !isFinite(k)) {
+    const a = new Int32Array(n);
+    for (let i = 0;i < n; i++)
+      a[i] = i;
+    return [a];
+  }
+  let x0 = Infinity, x1 = -Infinity, z0 = Infinity, z1 = -Infinity;
+  for (let i = 0;i < n; i++) {
+    const a = x(i), b = z(i);
+    if (a < x0)
+      x0 = a;
+    if (a > x1)
+      x1 = a;
+    if (b < z0)
+      z0 = b;
+    if (b > z1)
+      z1 = b;
+  }
+  const G = Math.max(1, Math.ceil(Math.sqrt(n / k)));
+  const sx = (x1 - x0) / G || 1, sz = (z1 - z0) / G || 1;
+  const cell = new Int32Array(n), cnt = new Int32Array(G * G);
+  for (let i = 0;i < n; i++) {
+    const c = Math.min(G - 1, Math.floor((x(i) - x0) / sx)) * G + Math.min(G - 1, Math.floor((z(i) - z0) / sz));
+    cell[i] = c;
+    cnt[c]++;
+  }
+  const out = [];
+  const at = new Int32Array(G * G).fill(-1);
+  const fill = new Int32Array(G * G);
+  for (let c = 0;c < G * G; c++)
+    if (cnt[c]) {
+      at[c] = out.length;
+      out.push(new Int32Array(cnt[c]));
+    }
+  for (let i = 0;i < n; i++) {
+    const c = cell[i];
+    out[at[c]][fill[c]++] = i;
+  }
+  return out;
+}
+
+class LdrLodRoot extends THREE.LOD {
+  clusters = [];
+  vpH = 1080;
+  px = 0.5;
+  edgePpl = 0.025;
+  enabled = true;
+  apply = () => {};
+  inv = new THREE.Matrix4;
+  cp = new THREE.Vector3;
+  constructor() {
+    super();
+    this.autoUpdate = true;
+  }
+  raycast() {}
+  update(camera) {
+    if (!this.enabled || !this.clusters.length)
+      return;
+    const pm = camera.projectionMatrix.elements;
+    const persp = camera.isPerspectiveCamera || pm[15] === 0;
+    const k = this.vpH / 2 * Math.abs(pm[5]);
+    this.inv.copy(this.matrixWorld).invert();
+    this.cp.setFromMatrixPosition(camera.matrixWorld).applyMatrix4(this.inv);
+    const { x, y, z } = this.cp;
+    const tau = this.px, eppl = this.edgePpl;
+    for (const c of this.clusters) {
+      const cx = c.s.center.x - x, cy = c.s.center.y - y, cz = c.s.center.z - z;
+      const d = Math.sqrt(cx * cx + cy * cy + cz * cz) - c.s.radius;
+      const ppl = persp ? d > 0.000001 ? k / d : Infinity : k;
+      let L = 0;
+      for (let i = c.lv.length - 1;i > 0; i--)
+        if (c.lv[i].err * ppl <= tau) {
+          L = i;
+          break;
+        }
+      const e = ppl >= eppl;
+      if (L !== c.cur || e !== c.edgeOk) {
+        c.cur = L;
+        c.edgeOk = e;
+        this.apply(c);
+      }
+    }
+  }
+}
+function buildStudMeshes(insts, H, cull, arr, Q, LOD, color, matF, matB, steps, colorIndex) {
+  const bucketOf = new Map;
+  const bKind = [], bMirror = [];
+  const bAll = [];
+  const studBucket = new Uint16Array(cull.nStuds);
+  const sx = new Float32Array(cull.nStuds), sz = new Float32Array(cull.nStuds);
+  forEachStud(insts, H, (j, _i, w, kind) => {
+    const neg = det12(w) < 0;
+    const k = neg ? kind + "#m" : kind;
+    let b = bucketOf.get(k);
+    if (b === undefined) {
+      b = bKind.length;
+      bucketOf.set(k, b);
+      bKind.push(kind);
+      bMirror.push(neg);
+      bAll.push(0);
+    }
+    studBucket[j] = b;
+    bAll[b]++;
+    sx[j] = w[0];
+    sz[j] = w[2];
+  });
+  const bIds = bAll.map((n) => new Int32Array(n));
+  {
+    const f = bAll.map(() => 0);
+    for (let j = 0;j < cull.nStuds; j++) {
+      const b = studBucket[j];
+      bIds[b][f[b]++] = j;
+    }
+  }
+  const studCl = new Int32Array(cull.nStuds), studSlot = new Int32Array(cull.nStuds);
+  const sMesh = [];
+  bKind.forEach((kind, b) => {
+    const g = geom(H.studKinds[kind].body, arr, Q);
+    const ids = bIds[b];
+    for (const c of gridClusters(ids.length, (i) => sx[ids[i]], (i) => sz[ids[i]], LOD ? 16384 : Infinity)) {
+      const ci = sMesh.length;
+      let v = 0;
+      for (const i of c)
+        if (!cull.studHidden[ids[i]])
+          v++;
+      let vc = 0, hc = v;
+      for (const i of c) {
+        const j = ids[i];
+        studCl[j] = ci;
+        studSlot[j] = cull.studHidden[j] ? hc++ : vc++;
+      }
+      if (!g) {
+        sMesh.push(null);
+        continue;
+      }
+      const im = newIM(g, bMirror[b] ? matB : matF, c.length);
+      im.instanceColor = new THREE.InstancedBufferAttribute(new Float32Array(c.length * 3), 3);
+      const n = c.length;
+      sMesh.push({ im, kind, vis: v, ...steps ? { slots: { own: new Int32Array(n), hide: new Int32Array(n), inst: new Int32Array(n), stud: new Int16Array(n), col: new Uint16Array(n) } } : {} });
+    }
+  });
+  forEachStud(insts, H, (j, owner, w, _kind, col, si) => {
+    const sm = sMesh[studCl[j]];
+    if (!sm)
+      return;
+    const im = sm.im;
+    const slot = studSlot[j];
+    if (sm.slots) {
+      const t = sm.slots;
+      t.own[slot] = steps[owner];
+      t.hide[slot] = cull.studHideStep[j];
+      t.inst[slot] = owner;
+      t.stud[slot] = si;
+      t.col[slot] = colorIndex(col);
+    }
+    writeM4(im.instanceMatrix.array, slot * 16, w);
+    color(col).toArray(im.instanceColor.array, slot * 3);
+  });
+  return sMesh;
 }
 function buildLdrScene(insts, pack, P, color, mark) {
   const { header: H, arr } = pack;
-  const root = new THREE.Group;
+  const Q = P.quant !== false;
+  const LOD = P.lod !== false;
+  const root = new LdrLodRoot;
+  root.enabled = LOD;
+  root.px = P.lodPx ?? 0.5;
+  root.edgePpl = (P.lodEdgePx ?? 0.5) / 20;
+  const trackVp = (r) => {
+    const rt = r.getRenderTarget();
+    const h = rt ? rt.height : r.getContext().drawingBufferHeight;
+    if (h)
+      root.vpH = h;
+  };
   const matF = makeMaterial(P.side === "front" ? THREE.FrontSide : THREE.DoubleSide), matB = makeMaterial(P.side === "front" ? THREE.BackSide : THREE.DoubleSide);
   const matD = makeMaterial(THREE.DoubleSide);
   let nUncert = 0;
-  const det = (m) => m[3] * (m[7] * m[11] - m[8] * m[10]) - m[4] * (m[6] * m[11] - m[8] * m[9]) + m[5] * (m[6] * m[10] - m[7] * m[9]);
   const byPart = new Map;
   insts.forEach((it, i) => {
     if (H.parts[it.part]) {
-      const k = it.part + (det(it.m) < 0 ? "#m" : "");
+      const k = it.part + (det12(it.m) < 0 ? "#m" : "");
       (byPart.get(k) || byPart.set(k, []).get(k)).push(i);
     }
   });
-  const cull = computeCulling(insts, H);
+  const steps = P.steps;
+  let cull = cullCore(insts, H, steps);
   mark("culling");
+  const stepBatches = [];
+  const instM = steps ? new Float64Array(insts.length * 12) : null;
+  const instPP = [];
+  const palette = [];
+  const palIdx = new Map;
+  const colorIndex = (c) => {
+    let i = palIdx.get(c);
+    if (i === undefined) {
+      i = palette.length;
+      palette.push(color(c));
+      palIdx.set(c, i);
+    }
+    return i;
+  };
+  const instCol = steps ? new Uint16Array(insts.length) : null;
+  if (instM)
+    insts.forEach((it, i) => {
+      for (let k = 0;k < 12; k++)
+        instM[i * 12 + k] = it.m[k];
+      instPP.push(prepPart(H, it.part));
+      instCol[i] = colorIndex(it.color);
+    });
   const edgeObjs = [];
   const condObjs = [];
   const wantCond = P.cond !== false && (P.edges === "idx" || P.edges === true);
   let condMat = null;
   const cmat = () => condMat ??= condLineMat();
+  let lineMatShared = null;
+  const lmat = () => lineMatShared ??= sharedLineMat();
   const condCache = new Map;
-  const addCond = (entry, im, which = "body") => {
+  const addCond = (entry, im, cl, which = "body") => {
     if (!wantCond)
       return null;
     const ck = which === "under" ? entry.condlu : entry.condl;
@@ -1142,12 +1607,40 @@ function buildLdrScene(insts, pack, P, color, mark) {
     const l = condEdges(cb, im, cmat());
     edgeObjs.push(l);
     condObjs.push(l);
+    cl.cond.push(l);
     root.add(l);
     return l;
   };
-  const stats = { studsTotal: cull.studs.length, studsHidden: cull.studs.filter((s) => s.hidden).length, undersTotal: 0, undersHidden: 0 };
+  const lineCache = new Map;
+  const addLines = (ref, im, cl) => {
+    let w = lineCache.get(ref);
+    if (!w) {
+      const r = weldLines(arr(ref));
+      lineCache.set(ref, w = { P: new THREE.BufferAttribute(r.P, 3), I: new THREE.BufferAttribute(r.I, 1) });
+    }
+    const g = new THREE.InstancedBufferGeometry;
+    g.setAttribute("position", w.P);
+    g.setIndex(w.I);
+    g.setAttribute("instanceMatrix", im.instanceMatrix);
+    g.instanceCount = im.count;
+    const l = new THREE.LineSegments(g, lmat());
+    l.frustumCulled = false;
+    edgeObjs.push(l);
+    cl.lines.push(l);
+    root.add(l);
+    return l;
+  };
+  const stats = { studsTotal: cull.nStuds, studsHidden: cull.studsHidden, undersTotal: 0, undersHidden: 0 };
   const toggles = [];
   const studMeshes = [];
+  const countTo = (objs) => ({ set count(n) {
+    for (const o of objs()) {
+      if (o.isInstancedMesh)
+        o.count = n;
+      else
+        o.geometry.instanceCount = n;
+    }
+  } });
   const wantTex = P.tex !== false && !!H.textures;
   const texCache = new Map;
   const texMats = new Map;
@@ -1169,160 +1662,256 @@ function buildLdrScene(insts, pack, P, color, mark) {
     return m;
   };
   let texBatches = 0;
-  for (const [pk, ids] of byPart) {
+  const newCluster = (s) => {
+    const c = { s, lv: [], lines: [], cond: [], cur: 0, edgeOk: true };
+    root.clusters.push(c);
+    return c;
+  };
+  const lodLevels = (b, base, mat) => !LOD || P.lodMesh === false || !b?.lod ? [] : b.lod.map((l) => {
+    const im = new THREE.InstancedMesh(geom(l, arr, Q), mat, 0);
+    im.instanceMatrix = base.instanceMatrix;
+    im.count = base.count;
+    im.instanceColor = base.instanceColor;
+    im.boundingSphere = base.boundingSphere;
+    im.visible = false;
+    im.onBeforeRender = trackVp;
+    im.userData.ldrLod = true;
+    root.add(im);
+    return { objs: [im], err: l.err };
+  });
+  const tris = (b) => b ? b.tris ?? 0 : 0;
+  const kFor = (t) => LOD ? Math.max(256, Math.min(16384, Math.round(262144 / Math.max(1, t)))) : Infinity;
+  for (const [pk, idsAll] of byPart) {
     const part = pk.replace(/#m$/, "");
     const p = H.parts[part];
     const mat = P.uncertDouble !== false && p.uncert ? (nUncert++, matD) : pk.endsWith("#m") ? matB : matF;
     const textured = wantTex && !!p.tex;
-    const body = geom(textured ? p.tbody : p.body, arr);
-    let bodyIm = null;
-    const place = (im) => {
-      ids.forEach((id, k) => {
-        im.setMatrixAt(k, toM4(insts[id].m));
-        im.setColorAt(k, color(insts[id].color));
-      });
-      im.computeBoundingSphere();
-      root.add(im);
-    };
-    if (body) {
-      const im = bodyIm = new THREE.InstancedMesh(body, mat, ids.length);
-      place(im);
-    }
-    if (textured)
-      for (const tb of p.tex) {
-        const g = geom(tb, arr);
-        const im = new THREE.InstancedMesh(g, texMat(tb.t, mat, !!tb.wrapU), ids.length);
-        texBatches++;
-        if (bodyIm) {
-          im.instanceMatrix = bodyIm.instanceMatrix;
-          im.instanceColor = bodyIm.instanceColor;
-          im.boundingSphere = bodyIm.boundingSphere;
-          root.add(im);
-        } else {
-          place(im);
-          bodyIm = im;
-        }
+    const bodyB = textured ? p.tbody : p.body;
+    const body = geom(bodyB, arr, Q);
+    const groups = gridClusters(idsAll.length, (i) => insts[idsAll[i]].m[0], (i) => insts[idsAll[i]].m[2], textured ? Infinity : kFor(tris(p.body) + tris(p.under)));
+    for (const g of groups) {
+      const ids = Array.from(g, (i) => idsAll[i]);
+      let bodyIm = null;
+      const lv0 = [];
+      const place = (im) => {
+        fillInstances(im, ids, insts, color);
+        im.computeBoundingSphere();
+        root.add(im);
+      };
+      if (body) {
+        const im = bodyIm = newIM(body, mat, ids.length);
+        place(im);
+        lv0.push(im);
       }
-    if (P.edges === "idx" && p.edges && bodyIm) {
-      const l = sharedLines(arr(p.edges), bodyIm);
-      edgeObjs.push(l);
-      root.add(l);
-    }
-    if (bodyIm)
-      addCond(p, bodyIm);
-    const under = geom(p.under, arr);
-    if (under) {
-      const ord = [...ids.filter((i) => !cull.underHidden[i]), ...ids.filter((i) => cull.underHidden[i])];
-      const vis = ids.filter((i) => !cull.underHidden[i]).length;
-      stats.undersTotal += ids.length;
-      stats.undersHidden += ids.length - vis;
-      const im = new THREE.InstancedMesh(under, mat, ids.length);
-      ord.forEach((id, k) => {
-        im.setMatrixAt(k, toM4(insts[id].m));
-        im.setColorAt(k, color(insts[id].color));
-      });
-      im.computeBoundingSphere();
-      im.count = P.cullUnder ? vis : ids.length;
-      root.add(im);
-      toggles.push({ mesh: im, all: ids.length, visible: vis, flag: "under" });
-      {
-        const cl = addCond(p, im, "under");
-        if (cl) {
-          toggles.push({ mesh: { set count(n) {
-            cl.geometry.instanceCount = n;
-          } }, all: ids.length, visible: vis, flag: "under" });
-          cl.geometry.instanceCount = im.count;
+      if (textured)
+        for (const tb of p.tex) {
+          const gg = geom(tb, arr, Q);
+          const im = newIM(gg, texMat(tb.t, mat, !!tb.wrapU), ids.length);
+          texBatches++;
+          lv0.push(im);
+          if (bodyIm) {
+            im.instanceMatrix = bodyIm.instanceMatrix;
+            im.instanceColor = bodyIm.instanceColor;
+            im.boundingSphere = bodyIm.boundingSphere;
+            root.add(im);
+          } else {
+            place(im);
+            bodyIm = im;
+          }
+        }
+      if (bodyIm) {
+        const cl = newCluster(bodyIm.boundingSphere);
+        lv0.forEach((o) => o.onBeforeRender = trackVp);
+        cl.lv.push({ objs: lv0, err: 0 }, ...textured ? [] : lodLevels(p.body, bodyIm, mat));
+        if (P.edges === "idx" && p.edges)
+          addLines(p.edges, bodyIm, cl);
+        addCond(p, bodyIm, cl);
+        if (steps)
+          stepBatches.push({ im: bodyIm, objs: [...cl.lv.flatMap((l) => l.objs), ...cl.lines, ...cl.cond], own: Int32Array.from(ids, (id) => steps[id]), hide: null, flag: "body", inst: Int32Array.from(ids), stud: null, col: Uint16Array.from(ids, (id) => instCol[id]) });
+        if (P.edges === true && p.edges) {
+          const mats = new Float32Array(ids.length * 16);
+          ids.forEach((id, k) => writeM4(mats, k * 16, insts[id].m));
+          {
+            const l = instancedLines(arr(p.edges), mats, ids.length);
+            edgeObjs.push(l);
+            cl.lines.push(l);
+            root.add(l);
+          }
         }
       }
-    }
-    if (P.edges === true && p.edges) {
-      const mats = new Float32Array(ids.length * 16);
-      ids.forEach((id, k) => toM4(insts[id].m).toArray(mats, k * 16));
-      {
-        const l = instancedLines(arr(p.edges), mats, ids.length);
-        edgeObjs.push(l);
-        root.add(l);
+      const under = geom(p.under, arr, Q);
+      if (under) {
+        const ord = [...ids.filter((i) => !cull.underHidden[i]), ...ids.filter((i) => cull.underHidden[i])];
+        const vis = ids.length - ids.reduce((a, i) => a + cull.underHidden[i], 0);
+        stats.undersTotal += ids.length;
+        stats.undersHidden += ids.length - vis;
+        const im = newIM(under, mat, ids.length);
+        fillInstances(im, ord, insts, color);
+        im.onBeforeRender = trackVp;
+        im.computeBoundingSphere();
+        im.count = P.cullUnder ? vis : ids.length;
+        root.add(im);
+        const cl = newCluster(im.boundingSphere);
+        cl.lv.push({ objs: [im], err: 0 }, ...lodLevels(p.under, im, mat));
+        addCond(p, im, cl, "under");
+        const objs = [...cl.lv.flatMap((l) => l.objs), ...cl.cond];
+        objs.forEach((o) => {
+          if (!o.isInstancedMesh)
+            o.geometry.instanceCount = im.count;
+        });
+        toggles.push({ mesh: countTo(() => objs), all: ids.length, visible: vis, flag: "under" });
+        if (steps)
+          stepBatches.push({ im, objs, own: Int32Array.from(ord, (id) => steps[id]), hide: Int32Array.from(ord, (id) => cull.underHideStep[id]), flag: "under", inst: Int32Array.from(ord), stud: null, col: Uint16Array.from(ord, (id) => instCol[id]) });
       }
     }
   }
-  const byKind = new Map;
-  for (const s of cull.studs) {
-    const k = s.kind + (det(s.w) < 0 ? "#m" : "");
-    (byKind.get(k) || byKind.set(k, []).get(k)).push(s);
-  }
-  for (const [kk, list] of byKind) {
-    const kind = kk.replace(/#m$/, "");
-    const mat = kk.endsWith("#m") ? matB : matF;
+  const sMesh = buildStudMeshes(insts, H, cull, arr, Q, LOD, color, matF, matB, steps, steps && colorIndex);
+  const sKind = sMesh.map((x) => x?.kind ?? "");
+  const sVis = sMesh.map((x) => x?.vis ?? 0);
+  const STUD_ERR = 12;
+  sMesh.forEach((sm, ci) => {
+    if (!sm)
+      return;
+    const im = sm.im;
+    const kind = sKind[ci];
     const k = H.studKinds[kind];
-    const g = geom(k.body, arr);
-    if (!g)
-      continue;
-    const ord = [...list.filter((s) => !s.hidden), ...list.filter((s) => s.hidden)];
-    const vis = list.filter((s) => !s.hidden).length;
-    const im = new THREE.InstancedMesh(g, mat, ord.length);
-    ord.forEach((s, i) => {
-      im.setMatrixAt(i, toM4(s.w));
-      im.setColorAt(i, color(s.color));
-    });
+    const vis = sVis[ci], all = im.instanceMatrix.count;
     im.computeBoundingSphere();
-    im.count = P.cullStuds ? vis : ord.length;
+    im.count = P.cullStuds ? vis : all;
+    im.onBeforeRender = trackVp;
+    im.userData.ldrStud = true;
     root.add(im);
-    toggles.push({ mesh: im, all: ord.length, visible: vis, flag: "studs" });
     studMeshes.push({ im, kind });
-    if (P.edges === "idx" && k.edges) {
-      const l = sharedLines(arr(k.edges), im);
-      edgeObjs.push(l);
-      root.add(l);
-      toggles.push({ mesh: { set count(n) {
-        l.geometry.instanceCount = n;
-      } }, all: ord.length, visible: vis, flag: "studs" });
-      l.geometry.instanceCount = im.count;
-    }
-    {
-      const cl = P.condStuds === false ? null : addCond(k, im);
-      if (cl) {
-        toggles.push({ mesh: { set count(n) {
-          cl.geometry.instanceCount = n;
-        } }, all: ord.length, visible: vis, flag: "studs" });
-        cl.geometry.instanceCount = im.count;
-      }
-    }
+    const cl = newCluster(im.boundingSphere);
+    cl.lv.push({ objs: [im], err: 0 });
+    if (LOD && P.lodStuds !== false)
+      cl.lv.push({ objs: [], err: STUD_ERR });
+    if (P.edges === "idx" && k.edges)
+      addLines(k.edges, im, cl);
+    if (P.condStuds !== false)
+      addCond(k, im, cl);
     if (P.edges === true && k.edges) {
-      const mats = new Float32Array(ord.length * 16);
-      ord.forEach((s, i) => toM4(s.w).toArray(mats, i * 16));
-      const l = instancedLines(arr(k.edges), mats, P.cullStuds ? vis : ord.length);
+      const l = instancedLines(arr(k.edges), im.instanceMatrix.array.slice(), im.count);
       edgeObjs.push(l);
+      cl.lines.push(l);
       root.add(l);
-      toggles.push({ mesh: { set count(n) {
-        l.geometry.instanceCount = n;
-      } }, all: ord.length, visible: vis, flag: "studs" });
     }
-  }
+    const objs = [im, ...cl.lines, ...cl.cond];
+    objs.forEach((o) => {
+      if (!o.isInstancedMesh)
+        o.geometry.instanceCount = im.count;
+    });
+    toggles.push({ mesh: countTo(() => objs), all, visible: vis, flag: "studs" });
+    if (sm.slots)
+      stepBatches.push({ im, objs, flag: "studs", ...sm.slots });
+  });
   stats.uncertParts = Object.values(H.parts).filter((x) => x.uncert).length;
   stats.uncertBatches = nUncert;
   let condOn = true, edgesOn = true;
+  root.apply = (c) => {
+    c.lv.forEach((l, i) => {
+      for (const o of l.objs)
+        o.visible = i === c.cur;
+    });
+    const lineVis = edgesOn && c.edgeOk && (c.cur === 0 || !LOD || c.lv[c.cur].objs.length > 0);
+    for (const o of c.lines)
+      o.visible = lineVis;
+    for (const o of c.cond)
+      o.visible = lineVis && condOn;
+  };
+  const refresh = () => root.clusters.forEach(root.apply);
   const setEdges = (v) => {
     edgesOn = v;
-    edgeObjs.forEach((o) => o.visible = v && (condOn || !condObjs.includes(o)));
+    refresh();
   };
   const setCond = (v) => {
     condOn = v;
-    condObjs.forEach((o) => o.visible = v && edgesOn);
+    refresh();
   };
+  refresh();
   stats.condBatches = condObjs.length;
   stats.texBatches = texBatches;
   stats.textures = texCache.size;
+  stats.clusters = root.clusters.length;
   const texturesReady = Promise.all(pending).then(() => {});
+  let stepS = STEP_NEVER - 1, cullS = !!P.cullStuds, cullU = !!P.cullUnder;
+  const applySteps = () => {
+    const st = { studsTotal: 0, studsHidden: 0, undersTotal: 0, undersHidden: 0 };
+    const S = stepS;
+    const wm = new Float64Array(12);
+    for (const b of stepBatches) {
+      const MA = b.im.instanceMatrix.array, CA = b.im.instanceColor.array;
+      const useHide = b.flag === "studs" ? cullS : b.flag === "under" ? cullU : false;
+      const { own, hide, inst, stud, col } = b;
+      let w = 0;
+      for (let i = 0;i < own.length; i++) {
+        if (own[i] > S)
+          continue;
+        const hid = !!hide && hide[i] <= S;
+        if (b.flag === "studs") {
+          st.studsTotal++;
+          if (hid)
+            st.studsHidden++;
+        } else if (b.flag === "under") {
+          st.undersTotal++;
+          if (hid)
+            st.undersHidden++;
+        }
+        if (useHide && hid)
+          continue;
+        const n = inst[i];
+        if (stud) {
+          mul12To(instM, instPP[n].studM, stud[i] * 12, wm, n * 12);
+          writeM4(MA, w * 16, wm);
+        } else
+          writeM4(MA, w * 16, instM, n * 12);
+        palette[col[i]].toArray(CA, w * 3);
+        w++;
+      }
+      b.im.instanceMatrix.needsUpdate = true;
+      b.im.instanceColor.needsUpdate = true;
+      for (const o of b.objs) {
+        if (o.isInstancedMesh)
+          o.count = w;
+        else
+          o.geometry.instanceCount = w;
+      }
+    }
+    return st;
+  };
   const setCull = (studs, under) => {
+    cullS = studs;
+    cullU = under;
+    if (steps) {
+      applySteps();
+      return;
+    }
     for (const t of toggles)
       t.mesh.count = (t.flag === "studs" ? studs : under) ? t.visible : t.all;
   };
+  const setStep = (s) => {
+    if (!steps)
+      throw new Error("buildLdrScene: setStep needs P.steps");
+    stepS = s == null ? STEP_NEVER - 1 : s;
+    return applySteps();
+  };
   const box = new THREE.Box3;
   for (const it of insts) {
-    const p = H.parts[it.part];
-    if (!p)
+    if (!H.parts[it.part])
       continue;
-    box.expandByPoint(new THREE.Vector3(it.m[0], it.m[1], it.m[2]));
+    const m = it.m;
+    if (m[0] < box.min.x)
+      box.min.x = m[0];
+    if (m[1] < box.min.y)
+      box.min.y = m[1];
+    if (m[2] < box.min.z)
+      box.min.z = m[2];
+    if (m[0] > box.max.x)
+      box.max.x = m[0];
+    if (m[1] > box.max.y)
+      box.max.y = m[1];
+    if (m[2] > box.max.z)
+      box.max.z = m[2];
   }
   const setSide = (front) => {
     matF.side = front ? THREE.FrontSide : THREE.DoubleSide;
@@ -1339,13 +1928,26 @@ function buildLdrScene(insts, pack, P, color, mark) {
     for (const s of studMeshes) {
       const k2 = alt.header.studKinds[s.kind] ? s.kind : Object.keys(alt.header.studKinds).find((k) => k.replace("p/8/", "p/") === s.kind.replace("p/8/", "p/"));
       if (k2)
-        s.im.geometry = geom(alt.header.studKinds[k2].body, alt.arr);
+        s.im.geometry = geom(alt.header.studKinds[k2].body, alt.arr, Q);
     }
     return () => studMeshes.forEach((s, i) => s.im.geometry = saved[i]);
   };
-  return { root, stats, setCull, setSide, setEdges, setCond, swapStuds, box, texturesReady };
+  const setLod = (on) => {
+    root.enabled = on && LOD;
+    if (!root.enabled) {
+      for (const c of root.clusters) {
+        c.cur = 0;
+        c.edgeOk = true;
+      }
+      refresh();
+    }
+  };
+  insts = null;
+  cull = null;
+  byPart.clear();
+  return { root, stats, setCull, setSide, setEdges, setCond, swapStuds, setLod, setStep, box, texturesReady };
 }
-// src/scene.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/scene.ts
 import * as THREE2 from "three";
 function colorFn(src, pack, fallback) {
   const table = new Map;
@@ -1430,11 +2032,11 @@ function createLdrObject(instances, pack, options = {}) {
     }
     cur = null;
   };
-  const build = (step) => {
+  const multiStep = uniq.length > 1;
+  const drawnAt = (step) => all.filter((i, k) => (step == null || stepOf[k] <= step) && pack.header.parts[i.part]).length;
+  const build = () => {
     const t0 = performance.now();
-    disposeCur();
-    const insts = step == null ? all : all.filter((_, k) => stepOf[k] <= step);
-    cur = buildLdrScene(insts, pack, { pack: "", cullStuds: cs, cullUnder: cu, edges: edges ? "idx" : false, side, cond, condStuds: o.conditionalStudLines !== false, tex: o.textures !== false }, color, () => {});
+    cur = buildLdrScene(all, pack, { pack: "", cullStuds: cs, cullUnder: cu, edges: edges ? "idx" : false, side, cond, condStuds: o.conditionalStudLines !== false, tex: o.textures !== false, lod: o.lod !== false, lodPx: o.lodPx, lodEdgePx: o.lodEdgePx, steps: multiStep ? stepOf : undefined }, color, () => {});
     pairs.clear();
     if (o.material === "plastic")
       cur.root.traverse((x) => {
@@ -1449,17 +2051,25 @@ function createLdrObject(instances, pack, options = {}) {
     if (!cond)
       cur.setCond(false);
     object.add(cur.root);
-    Object.assign(stats, { drawn: insts.filter((i) => pack.header.parts[i.part]).length, studsTotal: cur.stats.studsTotal, studsHidden: cur.stats.studsHidden, undersTotal: cur.stats.undersTotal, undersHidden: cur.stats.undersHidden, condBatches: cur.stats.condBatches ?? 0, texBatches: cur.stats.texBatches ?? 0, textures: cur.stats.textures ?? 0, buildMs: performance.now() - t0 });
+    Object.assign(stats, { drawn: drawnAt(null), studsTotal: cur.stats.studsTotal, studsHidden: cur.stats.studsHidden, undersTotal: cur.stats.undersTotal, undersHidden: cur.stats.undersHidden, condBatches: cur.stats.condBatches ?? 0, texBatches: cur.stats.texBatches ?? 0, textures: cur.stats.textures ?? 0, clusters: cur.stats.clusters ?? 0, buildMs: performance.now() - t0 });
     api.texturesReady = cur.texturesReady;
   };
+  const setStep = (step) => {
+    if (!multiStep)
+      return;
+    const t0 = performance.now();
+    Object.assign(stats, cur.setStep(step), { drawn: drawnAt(step), buildMs: performance.now() - t0 });
+  };
   const api = { texturesReady: Promise.resolve() };
-  build(o.step ?? null);
+  build();
+  if (o.step != null)
+    setStep(o.step);
   return Object.assign(api, {
     object,
     stats,
     stepCount: uniq.length,
     stepViews,
-    setStep: (s) => build(s),
+    setStep,
     setEdges: (v) => {
       edges = v;
       cur.setEdges(v);
@@ -1473,6 +2083,7 @@ function createLdrObject(instances, pack, options = {}) {
       cu = b;
       cur.setCull(a, b);
     },
+    setLod: (v) => cur.setLod(v),
     setSide: (s) => {
       side = s;
       cur.setSide(s === "front");
@@ -1485,7 +2096,7 @@ function createLdrObject(instances, pack, options = {}) {
       object.updateMatrixWorld(true);
       target.makeEmpty();
       object.traverse((x) => {
-        if (x.isInstancedMesh && x.count) {
+        if (x.isInstancedMesh && x.count && !x.userData.ldrLod) {
           x.computeBoundingBox();
           const b = x.boundingBox.clone().applyMatrix4(x.matrixWorld);
           target.union(b);
@@ -1496,7 +2107,7 @@ function createLdrObject(instances, pack, options = {}) {
     dispose: disposeCur
   });
 }
-// src/pack-io.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/pack-io.ts
 import { decompress } from "fzstd";
 async function decompressPack(data) {
   const u = data instanceof Uint8Array ? data : new Uint8Array(data);
@@ -1507,7 +2118,148 @@ async function decompressPack(data) {
     return new Response(new Blob([u]).stream().pipeThrough(new DecompressionStream("gzip"))).arrayBuffer();
   return own(u);
 }
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/cdn.ts
+import { decompress as decompress2 } from "fzstd";
+var DEFAULT_PARTS_CDN = "https://ldr-demo.vercel.app/cdn/v1/";
+var indexCache = new Map;
+var shardCache = new Map;
+function loadPartsIndex(cdn = DEFAULT_PARTS_CDN, f = fetch) {
+  let p = indexCache.get(cdn);
+  if (!p) {
+    p = f(cdn + "parts.json").then((r) => {
+      if (!r.ok)
+        throw new Error(`ldr: parts CDN index ${r.status} (${cdn}parts.json)`);
+      return r.json();
+    });
+    p.catch(() => indexCache.delete(cdn));
+    indexCache.set(cdn, p);
+  }
+  return p;
+}
+var isRange = (v) => Array.isArray(v) && v.length === 3 && typeof v[0] === "number" && typeof v[1] === "number" && (v[2] === "f32" || v[2] === "u16" || v[2] === "u8" || v[2] === "u32");
+var rebase = (v, d) => isRange(v) ? [v[0] + d, v[1], v[2]] : Array.isArray(v) ? v.map((x) => rebase(x, d)) : v && typeof v === "object" ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, rebase(x, d)])) : v;
+function mergePacks(packs, extra = {}) {
+  const payloads = [];
+  let off = 0;
+  const parts = {}, studKinds = {};
+  for (const p of packs) {
+    const buf = p.buffer;
+    if (!buf)
+      throw new Error("ldr: mergePacks needs packs from decodePack/loadPack");
+    const hl = new DataView(buf).getUint32(0, true);
+    const pay = new Uint8Array(buf, 4 + hl);
+    const d = off;
+    payloads.push(pay);
+    off += pay.byteLength;
+    const pad = (4 - off % 4) % 4;
+    if (pad) {
+      payloads.push(new Uint8Array(pad));
+      off += pad;
+    }
+    for (const [k, v] of Object.entries(p.header.parts ?? {}))
+      if (!(k in parts))
+        parts[k] = rebase(v, d);
+    for (const [k, v] of Object.entries(p.header.studKinds ?? {}))
+      if (!(k in studKinds))
+        studKinds[k] = rebase(v, d);
+  }
+  const h0 = packs[0]?.header ?? { version: 1, weld: true };
+  const header = new TextEncoder().encode(JSON.stringify({ ...h0, parts, studKinds, ...extra }));
+  const hpad = (4 - (4 + header.length) % 4) % 4;
+  const base = 4 + header.length + hpad;
+  const out = new Uint8Array(base + off);
+  new DataView(out.buffer).setUint32(0, header.length + hpad, true);
+  out.set(header, 4);
+  out.fill(32, 4 + header.length, base);
+  let o = base;
+  for (const p of payloads) {
+    out.set(p, o);
+    o += p.byteLength;
+  }
+  return decodePack(out.buffer);
+}
+async function loadParts(names, o = {}) {
+  const cdn = o.cdn ?? DEFAULT_PARTS_CDN, f = o.fetch ?? fetch, gap = o.gap ?? 65536;
+  const idx = await loadPartsIndex(cdn, f);
+  const want = [...new Set([...names].map(norm))];
+  const missing = [];
+  const todo = [];
+  for (const n of want) {
+    if (shardCache.has(cdn + n))
+      continue;
+    const e = idx.parts[n];
+    if (e)
+      todo.push({ name: n, off: e[0], len: e[1], file: e[2] ?? 0 });
+    else
+      missing.push(n);
+  }
+  todo.sort((a, b) => a.file - b.file || a.off - b.off);
+  const groups = [];
+  for (const t of todo) {
+    const g = groups[groups.length - 1];
+    if (g && g.file === t.file && t.off - g.end <= gap) {
+      g.end = Math.max(g.end, t.off + t.len);
+      g.items.push(t);
+    } else
+      groups.push({ file: t.file, start: t.off, end: t.off + t.len, items: [t] });
+  }
+  let bytes = 0;
+  let next = 0;
+  const worker = async () => {
+    while (next < groups.length) {
+      const g = groups[next++];
+      const r = await f(new URL(idx.archives[g.file], cdn).href, { headers: { Range: `bytes=${g.start}-${g.end - 1}` } });
+      if (!r.ok)
+        throw new Error(`ldr: parts CDN ${r.status}`);
+      let buf = new Uint8Array(await r.arrayBuffer());
+      if (r.status === 200)
+        buf = buf.subarray(g.start, g.end);
+      bytes += buf.byteLength;
+      for (const t of g.items) {
+        const raw = decompress2(buf.subarray(t.off - g.start, t.off - g.start + t.len));
+        const ab = raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength);
+        shardCache.set(cdn + t.name, decodePack(ab));
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(o.concurrency ?? 6, groups.length) }, worker));
+  const shards = want.filter((n) => shardCache.has(cdn + n)).map((n) => shardCache.get(cdn + n));
+  const pack = shards.length ? mergePacks(shards, { colors: idx.colors }) : decodePack(emptyPack(idx.colors));
+  return { pack, missing, requests: groups.length, bytes };
+}
+function emptyPack(colors) {
+  const h = new TextEncoder().encode(JSON.stringify({ version: 1, weld: true, parts: {}, studKinds: {}, colors }));
+  const pad = (4 - (4 + h.length) % 4) % 4;
+  const b = new Uint8Array(4 + h.length + pad).fill(32);
+  new DataView(b.buffer).setUint32(0, h.length + pad, true);
+  b.set(h, 4);
+  return b.buffer;
+}
+async function loadModel(source, o = {}) {
+  const t0 = performance.now();
+  const f = o.fetch ?? fetch;
+  const idxP = loadPartsIndex(o.cdn ?? DEFAULT_PARTS_CDN, f);
+  const text = o.text ? source : await f(source).then((r) => {
+    if (!r.ok)
+      throw new Error(`ldr: ${r.status} fetching ${source}`);
+    return r.text();
+  });
+  const t1 = performance.now();
+  const name = o.name ?? (o.text ? "main.ldr" : decodeURIComponent(source.split(/[?#]/)[0].split("/").pop() || "main.ldr"));
+  const insts = parseModel(text, name, { looseGeometry: false });
+  const t2 = performance.now();
+  await idxP;
+  const { pack, missing, requests, bytes } = await loadParts(insts.filter((i) => !i.embedded).map((i) => i.part), o);
+  const t3 = performance.now();
+  const obj = createLdrObject(insts, pack, o);
+  for (const m of missing)
+    if (!obj.stats.missing.includes(m))
+      obj.stats.missing.push(m);
+  const t4 = performance.now();
+  return Object.assign(obj, { pack, instances: insts, requests, bytes, timings: { fetchModel: t1 - t0, parse: t2 - t1, parts: t3 - t2, build: t4 - t3, total: t4 - t0 } });
+}
 export {
+  DEFAULT_PARTS_CDN,
   I as IDENTITY,
   buildLdrScene,
   colorToken,
@@ -1517,20 +2269,26 @@ export {
   createInstancedConditionalEdges,
   createInstancedEdges,
   createLdrObject,
+  cullCore,
   decodePack,
   decompressPack,
   fileKind,
   fileStepViews,
   flatten,
+  forEachStud,
   hash32,
   invert,
   isDirectColor,
+  loadModel,
   loadPack,
+  loadParts,
+  loadPartsIndex,
   looseFile,
   loosePartName,
   looseSource,
   looseSteps,
   makeMaterial,
+  mergePacks,
   mul,
   norm,
   parse,