lecodes-assets 2.4.10 → 2.5.0

package/dist/cli.js

@@ -4205,7 +4205,13 @@ var SLOTS, pick = (m, names) => {
         slots.push(`base=${nameOf(baseG)}`);
       }
     }
-    const baseColor = um.colors._BaseColor ?? um.colors._Color;
+    let baseColor = um.colors._BaseColor ?? um.colors._Color;
+    const tilling = um.colors._Color_Tilling;
+    if (tilling && um.floats._Tilling_Color !== undefined) {
+      const c = baseColor ?? [1, 1, 1, 1];
+      baseColor = [c[0] + 0.5 * tilling[0], c[1] + 0.5 * tilling[1], c[2] + 0.5 * tilling[2], c[3]];
+      slots.push(`base×(_Color + _Color_Tilling/2)`);
+    }
     if (baseColor)
       gm.setBaseColorFactor([baseColor[0], baseColor[1], baseColor[2], gm.getBaseColorFactor()[3]]);
     const live = (names) => names.map((n) => um.textures[n]).find((g) => g && (g.startsWith(PATH_GUID) || resolver.resolve(g))) ?? null;
@@ -6896,7 +6902,7 @@ async function planTexture(tex, root, maxSize = DEFAULT_MAX_SIZE, forceFmt) {
   } catch {
     return null;
   }
-  const resize = Math.max(width, height) > maxSize;
+  const resize = !isImpostorAtlas(tex) && Math.max(width, height) > maxSize;
   let desired = forceFmt ?? (hasAlpha ? "png" : "jpeg");
   if (desired === "jpeg" && hasAlpha)
     desired = "png";
@@ -6939,7 +6945,7 @@ async function applyTexturePlan(plan, maxSize = DEFAULT_MAX_SIZE) {
     plan.afterBytes = out.length;
   }
 }
-var DEFAULT_MAX_SIZE = 2048, HEAVY_PNG_MIN_DIM = 1024;
+var DEFAULT_MAX_SIZE = 2048, HEAVY_PNG_MIN_DIM = 1024, isImpostorAtlas = (tex) => !!tex.getExtras()?.lecodes?.impostor;
 var init_transcodeTextures = () => {};
 
 // src/doctor/transcodeKtx2.ts
@@ -7023,9 +7029,9 @@ async function planKtx2(tex, root, maxSize = DEFAULT_MAX_SIZE, policy = "hq") {
   } catch {
     return null;
   }
-  const codec = policy === "uastc" ? "uastc" : isNormal || isData ? "uastc" : "etc1s";
+  const codec = policy === "uastc" ? "uastc" : isNormal || isData || isImpostorAtlas(tex) ? "uastc" : "etc1s";
   const oetf = isNormal || isData ? "linear" : "srgb";
-  const resize = Math.max(width, height) > maxSize;
+  const resize = !isImpostorAtlas(tex) && Math.max(width, height) > maxSize;
   return {
     tex,
     name: tex.getName() || "?",
@@ -7083,7 +7089,7 @@ async function encodeOne(plan, enc, maxSize) {
     const snap4 = (n) => Math.max(4, Math.round(n / 4) * 4);
     let { width: tw, height: th } = plan;
     const m = Math.max(tw, th);
-    if (m > maxSize) {
+    if (plan.resize && m > maxSize) {
       const s = maxSize / m;
       tw = tw * s;
       th = th * s;
@@ -7424,6 +7430,8 @@ function planCardTrim(doc, opts) {
       const mat = prim.getMaterial();
       if (!mat || mat.getAlphaMode() !== "MASK" || prim.getMode() !== 4)
         continue;
+      if (mat.getExtras()?.lecodes?.impostor !== undefined)
+        continue;
       if (!prim.getAttribute("POSITION") || !prim.getAttribute("TEXCOORD_0"))
         continue;
       const tex = mat.getBaseColorTexture();
@@ -9815,6 +9823,586 @@ var init_probe2 = __esm(() => {
   init_mergeSkins();
 });
 
+// src/doctor/impostor.ts
+import { Logger as Logger3, PropertyType } from "@gltf-transform/core";
+import { prune as prune3 } from "@gltf-transform/functions";
+var impostorLabel = (r) => `${r.rows ? `${r.cols}×${r.rows}` : `oct ${r.cols}×${r.cols}`} frames · ${r.px} px (${r.width}×${r.height})`, LOD_RE, REPEAT = 10497, CLAMP = 33071, MIRROR = 33648, octDecode = (u, v) => {
+  const a = u * 2 - 1, b = v * 2 - 1;
+  const x = (a + b) / 2, z = (a - b) / 2, y = 1 - Math.abs(x) - Math.abs(z);
+  const l = Math.hypot(x, y, z) || 1;
+  return [x / l, y / l, z / l];
+}, normalEncode = (n) => {
+  const s = Math.abs(n[0]) + Math.abs(n[1]) + Math.abs(n[2]) || 1;
+  let px = n[0] / s, py = n[2] / s;
+  if (n[1] / s < 0) {
+    const sx = px >= 0 ? 1 : -1, sy = py >= 0 ? 1 : -1;
+    const ox = (1 - Math.abs(py)) * sx, oy = (1 - Math.abs(px)) * sy;
+    px = ox;
+    py = oy;
+  }
+  return [px * 0.5 + 0.5, py * 0.5 + 0.5];
+}, frameBasis = (d) => {
+  const ref = Math.abs(d[1]) < 0.999 ? [0, 1, 0] : [0, 0, -1];
+  let rx = ref[1] * d[2] - ref[2] * d[1], ry = ref[2] * d[0] - ref[0] * d[2], rz = ref[0] * d[1] - ref[1] * d[0];
+  const l = Math.hypot(rx, ry, rz) || 1;
+  rx /= l;
+  ry /= l;
+  rz /= l;
+  return { right: [rx, ry, rz], up: [d[1] * rz - d[2] * ry, d[2] * rx - d[0] * rz, d[0] * ry - d[1] * rx] };
+}, gridDirection = (i, k, A, E) => {
+  const az = i * 2 * Math.PI / A, el = k * (Math.PI / 2) / E;
+  return [Math.cos(el) * Math.sin(az), Math.sin(el), Math.cos(el) * Math.cos(az)];
+}, frame = (i, k, d, P) => ({ i, k, d, x0: i * P, x1: (i + 1) * P, y0: k * P, y1: (k + 1) * P }), gridLayout = (A, E, P) => {
+  const frames = [];
+  for (let k = 0;k < E; k++)
+    for (let i = 0;i < A; i++)
+      frames.push(frame(i, k, gridDirection(i, k, A, E), P));
+  return { cols: A, rows: E, px: P, width: A * P, height: E * P, frames };
+}, octLayout = (N, P) => {
+  const frames = [];
+  for (let j = 0;j < N; j++)
+    for (let i = 0;i < N; i++)
+      frames.push(frame(i, j, octDecode(i / (N - 1), j / (N - 1)), P));
+  return { cols: N, rows: 0, px: P, width: N * P, height: N * P, frames };
+}, isLevel0 = (n) => !!n.getMesh() && !LOD_RE.test(n.getName()), impostorBounds = (doc) => {
+  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+  const v = [];
+  for (const node of doc.getRoot().listNodes()) {
+    if (!isLevel0(node))
+      continue;
+    const m = node.getWorldMatrix();
+    for (const p of node.getMesh().listPrimitives()) {
+      const pos = p.getAttribute("POSITION");
+      if (!pos || p.getMode() !== 4)
+        continue;
+      for (let i = 0;i < pos.getCount(); i++) {
+        pos.getElement(i, v);
+        const x = m[0] * v[0] + m[4] * v[1] + m[8] * v[2] + m[12], y = m[1] * v[0] + m[5] * v[1] + m[9] * v[2] + m[13], z = m[2] * v[0] + m[6] * v[1] + m[10] * v[2] + m[14];
+        if (x < min[0])
+          min[0] = x;
+        if (y < min[1])
+          min[1] = y;
+        if (z < min[2])
+          min[2] = z;
+        if (x > max[0])
+          max[0] = x;
+        if (y > max[1])
+          max[1] = y;
+        if (z > max[2])
+          max[2] = z;
+      }
+    }
+  }
+  return min[0] <= max[0] ? { min, max } : null;
+}, makeSlot = async (mat, images, log) => {
+  const f = mat?.getBaseColorFactor() ?? [1, 1, 1, 1];
+  const mask = mat?.getAlphaMode() === "MASK";
+  const slot = { mask, cull: !mask && !mat?.getDoubleSided(), cutoff: mat ? mat.getAlphaCutoff() : 0.5, f: [f[0], f[1], f[2], f[3]], img: null, w: 0, h: 0, wrapS: REPEAT, wrapT: REPEAT, set: 0 };
+  const tex = mat?.getBaseColorTexture();
+  if (!mat || !tex)
+    return slot;
+  if ((tex.getMimeType() || "").includes("ktx2"))
+    throw new Error(`impostor: the base colour of material "${mat.getName()}" is already KTX2 — bake impostors before the KTX2 encode (from the source textures)`);
+  const info = mat.getBaseColorTextureInfo();
+  slot.set = info?.getTexCoord() ?? 0;
+  slot.wrapS = info?.getWrapS() ?? REPEAT;
+  slot.wrapT = info?.getWrapT() ?? REPEAT;
+  let job = images.get(tex);
+  if (!job) {
+    job = (async () => {
+      const bytes = tex.getImage();
+      const img = bytes ? await decodeImage(bytes, tex.getURI() || tex.getMimeType() || "texture.png") : null;
+      return img ? { img: img.data, w: img.width, h: img.height } : null;
+    })();
+    images.set(tex, job);
+  }
+  const img = await job;
+  if (!img) {
+    log(`   ⚠ impostor: the base colour of "${mat.getName()}" could not be decoded — drawn as its factor, opaque`);
+    slot.mask = false;
+    return slot;
+  }
+  slot.img = img.img;
+  slot.w = img.w;
+  slot.h = img.h;
+  return slot;
+}, collectLevel0 = async (doc, log) => {
+  const pos = [], nrm = [], uv = [], ao = [];
+  const tri = [], triSlot = [], face = [];
+  const slots = [], slotOf = new Map;
+  const images = new Map;
+  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+  const trisOfNode = new Map;
+  const v = [];
+  for (const node of doc.getRoot().listNodes()) {
+    if (!isLevel0(node))
+      continue;
+    const m = node.getWorldMatrix();
+    const ax = m[0], ay = m[1], az = m[2], bx = m[4], by = m[5], bz = m[6], cx = m[8], cy = m[9], cz = m[10];
+    const det = ax * (by * cz - bz * cy) - bx * (ay * cz - az * cy) + cx * (ay * bz - az * by);
+    const sg = det < 0 ? -1 : 1;
+    const n0 = [(by * cz - bz * cy) * sg, (bz * cx - bx * cz) * sg, (bx * cy - by * cx) * sg];
+    const n1 = [(cy * az - cz * ay) * sg, (cz * ax - cx * az) * sg, (cx * ay - cy * ax) * sg];
+    const n2 = [(ay * bz - az * by) * sg, (az * bx - ax * bz) * sg, (ax * by - ay * bx) * sg];
+    let nodeTris = 0;
+    for (const p of node.getMesh().listPrimitives()) {
+      const P = p.getAttribute("POSITION");
+      if (!P || p.getMode() !== 4)
+        continue;
+      const mat = p.getMaterial();
+      let si = slotOf.get(mat);
+      if (si === undefined) {
+        si = slots.length;
+        slots.push(await makeSlot(mat, images, log));
+        slotOf.set(mat, si);
+      }
+      const slot = slots[si];
+      const N = p.getAttribute("NORMAL"), T = p.getAttribute(`TEXCOORD_${slot.set}`), C = p.getAttribute("COLOR_0");
+      const base = pos.length / 3;
+      const count = P.getCount();
+      for (let i = 0;i < count; i++) {
+        P.getElement(i, v);
+        const x = m[0] * v[0] + m[4] * v[1] + m[8] * v[2] + m[12], y = m[1] * v[0] + m[5] * v[1] + m[9] * v[2] + m[13], z = m[2] * v[0] + m[6] * v[1] + m[10] * v[2] + m[14];
+        pos.push(x, y, z);
+        if (x < min[0])
+          min[0] = x;
+        if (y < min[1])
+          min[1] = y;
+        if (z < min[2])
+          min[2] = z;
+        if (x > max[0])
+          max[0] = x;
+        if (y > max[1])
+          max[1] = y;
+        if (z > max[2])
+          max[2] = z;
+        if (N) {
+          N.getElement(i, v);
+          const nx = n0[0] * v[0] + n1[0] * v[1] + n2[0] * v[2], ny = n0[1] * v[0] + n1[1] * v[1] + n2[1] * v[2], nz = n0[2] * v[0] + n1[2] * v[1] + n2[2] * v[2];
+          const l = Math.hypot(nx, ny, nz) || 1;
+          nrm.push(nx / l, ny / l, nz / l);
+        } else
+          nrm.push(0, 0, 0);
+        if (T) {
+          T.getElement(i, v);
+          uv.push(v[0], v[1]);
+        } else
+          uv.push(0, 0);
+        if (C) {
+          C.getElement(i, v);
+          ao.push(v[0]);
+        } else
+          ao.push(1);
+      }
+      const idx = p.getIndices();
+      const n = idx ? idx.getCount() : count;
+      for (let k = 0;k + 2 < n; k += 3) {
+        const a = base + (idx ? idx.getScalar(k) : k), b = base + (idx ? idx.getScalar(k + 1) : k + 1), c = base + (idx ? idx.getScalar(k + 2) : k + 2);
+        tri.push(a, b, c);
+        triSlot.push(si);
+        const e1x = pos[b * 3] - pos[a * 3], e1y = pos[b * 3 + 1] - pos[a * 3 + 1], e1z = pos[b * 3 + 2] - pos[a * 3 + 2];
+        const e2x = pos[c * 3] - pos[a * 3], e2y = pos[c * 3 + 1] - pos[a * 3 + 1], e2z = pos[c * 3 + 2] - pos[a * 3 + 2];
+        const fx = (e1y * e2z - e1z * e2y) * sg, fy = (e1z * e2x - e1x * e2z) * sg, fz = (e1x * e2y - e1y * e2x) * sg;
+        const fl = Math.hypot(fx, fy, fz) || 1;
+        face.push(fx / fl, fy / fl, fz / fl);
+        nodeTris++;
+      }
+    }
+    trisOfNode.set(node, nodeTris);
+  }
+  if (!tri.length)
+    return null;
+  let root = null, best = -1;
+  for (const [node, n] of trisOfNode) {
+    let nested = false;
+    for (let a = node.getParentNode();a; a = a.getParentNode())
+      if (trisOfNode.has(a)) {
+        nested = true;
+        break;
+      }
+    if (!nested && n > best) {
+      best = n;
+      root = node;
+    }
+  }
+  return {
+    pos: Float32Array.from(pos),
+    nrm: Float32Array.from(nrm),
+    uv: Float32Array.from(uv),
+    ao: Float32Array.from(ao),
+    tri: Uint32Array.from(tri),
+    triSlot: Uint16Array.from(triSlot),
+    face: Float32Array.from(face),
+    slots,
+    min,
+    max,
+    root
+  };
+}, SRGB_TO_LINEAR2, toSrgb8 = (x) => {
+  const c = x <= 0 ? 0 : x >= 1 ? 1 : x <= 0.0031308 ? x * 12.92 : 1.055 * Math.pow(x, 1 / 2.4) - 0.055;
+  return Math.round(c * 255);
+}, wrapI = (i, n, mode) => {
+  if (mode === CLAMP)
+    return i < 0 ? 0 : i >= n ? n - 1 : i;
+  if (mode === MIRROR) {
+    const p = 2 * n, k = (i % p + p) % p;
+    return k < n ? k : p - 1 - k;
+  }
+  return (i % n + n) % n;
+}, tapI, tapW, taps = (s, u, v) => {
+  const fx = u * s.w - 0.5, fy = v * s.h - 0.5;
+  const x0 = Math.floor(fx), y0 = Math.floor(fy), tx = fx - x0, ty = fy - y0;
+  const xa = wrapI(x0, s.w, s.wrapS), xb = wrapI(x0 + 1, s.w, s.wrapS), ya = wrapI(y0, s.h, s.wrapT), yb = wrapI(y0 + 1, s.h, s.wrapT);
+  tapI[0] = (ya * s.w + xa) * 4;
+  tapI[1] = (ya * s.w + xb) * 4;
+  tapI[2] = (yb * s.w + xa) * 4;
+  tapI[3] = (yb * s.w + xb) * 4;
+  tapW[0] = (1 - tx) * (1 - ty);
+  tapW[1] = tx * (1 - ty);
+  tapW[2] = (1 - tx) * ty;
+  tapW[3] = tx * ty;
+}, alphaAt = (s, u, v) => {
+  if (!s.img)
+    return s.f[3];
+  taps(s, u, v);
+  const d = s.img;
+  return (d[tapI[0] + 3] * tapW[0] + d[tapI[1] + 3] * tapW[1] + d[tapI[2] + 3] * tapW[2] + d[tapI[3] + 3] * tapW[3]) / 255 * s.f[3];
+}, DILATE_PASSES = 16, dilate = (base, data, covered, W, H, frameOf, nFrames) => {
+  let cur = covered.slice();
+  for (let pass = 0;pass < DILATE_PASSES; pass++) {
+    const next = cur.slice();
+    let changed = 0;
+    for (let y = 0;y < H; y++) {
+      for (let x = 0;x < W; x++) {
+        const i = y * W + x;
+        if (cur[i])
+          continue;
+        const f = frameOf[i];
+        let n = 0, r = 0, g = 0, b = 0, d0 = 0, d1 = 0, d2 = 0, d3 = 0;
+        for (let oy = -1;oy <= 1; oy++) {
+          const yy = y + oy;
+          if (yy < 0 || yy >= H)
+            continue;
+          for (let ox = -1;ox <= 1; ox++) {
+            const xx = x + ox;
+            if (xx < 0 || xx >= W)
+              continue;
+            const k = yy * W + xx;
+            if (!cur[k] || frameOf[k] !== f)
+              continue;
+            const o = k * 4;
+            r += base[o];
+            g += base[o + 1];
+            b += base[o + 2];
+            d0 += data[o];
+            d1 += data[o + 1];
+            d2 += data[o + 2];
+            d3 += data[o + 3];
+            n++;
+          }
+        }
+        if (!n)
+          continue;
+        const o = i * 4;
+        base[o] = Math.round(r / n);
+        base[o + 1] = Math.round(g / n);
+        base[o + 2] = Math.round(b / n);
+        data[o] = Math.round(d0 / n);
+        data[o + 1] = Math.round(d1 / n);
+        data[o + 2] = Math.round(d2 / n);
+        data[o + 3] = Math.round(d3 / n);
+        next[i] = 1;
+        changed++;
+      }
+    }
+    cur = next;
+    if (!changed)
+      break;
+  }
+  const sums = new Float64Array((nFrames + 1) * 8);
+  const all = nFrames * 8;
+  for (let i = 0;i < W * H; i++) {
+    if (!covered[i])
+      continue;
+    const o = i * 4;
+    for (const s of frameOf[i] >= 0 ? [frameOf[i] * 8, all] : [all]) {
+      sums[s] += base[o];
+      sums[s + 1] += base[o + 1];
+      sums[s + 2] += base[o + 2];
+      sums[s + 3] += data[o];
+      sums[s + 4] += data[o + 1];
+      sums[s + 5] += data[o + 2];
+      sums[s + 6] += data[o + 3];
+      sums[s + 7]++;
+    }
+  }
+  for (let i = 0;i < W * H; i++) {
+    if (cur[i])
+      continue;
+    let s = frameOf[i] >= 0 ? frameOf[i] * 8 : all;
+    if (!sums[s + 7])
+      s = all;
+    const n = sums[s + 7], o = i * 4;
+    if (!n) {
+      base[o] = base[o + 1] = base[o + 2] = 128;
+      data[o] = data[o + 1] = data[o + 2] = 128;
+      data[o + 3] = 255;
+      continue;
+    }
+    base[o] = Math.round(sums[s] / n);
+    base[o + 1] = Math.round(sums[s + 1] / n);
+    base[o + 2] = Math.round(sums[s + 2] / n);
+    data[o] = Math.round(sums[s + 3] / n);
+    data[o + 1] = Math.round(sums[s + 4] / n);
+    data[o + 2] = Math.round(sums[s + 5] / n);
+    data[o + 3] = Math.round(sums[s + 6] / n);
+  }
+}, invert4 = (m) => {
+  const [a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23, a30, a31, a32, a33] = Array.from(m);
+  const b00 = a00 * a11 - a01 * a10, b01 = a00 * a12 - a02 * a10, b02 = a00 * a13 - a03 * a10, b03 = a01 * a12 - a02 * a11;
+  const b04 = a01 * a13 - a03 * a11, b05 = a02 * a13 - a03 * a12, b06 = a20 * a31 - a21 * a30, b07 = a20 * a32 - a22 * a30;
+  const b08 = a20 * a33 - a23 * a30, b09 = a21 * a32 - a22 * a31, b10 = a21 * a33 - a23 * a31, b11 = a22 * a33 - a23 * a32;
+  let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  if (Math.abs(det) < 0.000000000001)
+    return null;
+  det = 1 / det;
+  return [
+    (a11 * b11 - a12 * b10 + a13 * b09) * det,
+    (a02 * b10 - a01 * b11 - a03 * b09) * det,
+    (a31 * b05 - a32 * b04 + a33 * b03) * det,
+    (a22 * b04 - a21 * b05 - a23 * b03) * det,
+    (a12 * b08 - a10 * b11 - a13 * b07) * det,
+    (a00 * b11 - a02 * b08 + a03 * b07) * det,
+    (a32 * b02 - a30 * b05 - a33 * b01) * det,
+    (a20 * b05 - a22 * b02 + a23 * b01) * det,
+    (a10 * b10 - a11 * b08 + a13 * b06) * det,
+    (a01 * b08 - a00 * b10 - a03 * b06) * det,
+    (a30 * b04 - a31 * b02 + a33 * b00) * det,
+    (a21 * b02 - a20 * b04 - a23 * b00) * det,
+    (a11 * b07 - a10 * b09 - a12 * b06) * det,
+    (a00 * b09 - a01 * b07 + a02 * b06) * det,
+    (a31 * b01 - a30 * b03 - a32 * b00) * det,
+    (a20 * b03 - a21 * b01 + a22 * b00) * det
+  ];
+}, encodePng2 = async (rgba, w, h) => {
+  const sharp = (await import("sharp")).default;
+  return new Uint8Array(await sharp(Buffer.from(rgba.buffer, rgba.byteOffset, rgba.byteLength), { raw: { width: w, height: h, channels: 4 } }).png().toBuffer());
+}, bakeImpostor = async (doc, opts) => {
+  const t0 = performance.now();
+  const log = opts.log ?? ((s) => console.log(s));
+  const g = await collectLevel0(doc, log);
+  if (!g)
+    return null;
+  const { pos, nrm, uv, ao, tri, triSlot, face, slots } = g;
+  const nv = pos.length / 3, nt = tri.length / 3;
+  const c = [(g.min[0] + g.max[0]) / 2, (g.min[1] + g.max[1]) / 2, (g.min[2] + g.max[2]) / 2];
+  let r2 = 0;
+  for (let v = 0;v < nv; v++) {
+    const dx = pos[v * 3] - c[0], dy = pos[v * 3 + 1] - c[1], dz = pos[v * 3 + 2] - c[2];
+    const d = dx * dx + dy * dy + dz * dz;
+    if (d > r2)
+      r2 = d;
+  }
+  const r = Math.sqrt(r2) || 0.001;
+  const height = g.max[1] - g.min[1];
+  const P = Math.max(4, Math.round((opts.px ?? (height >= 8 ? 256 : 128)) / 4) * 4);
+  const layout = opts.rows > 0 ? gridLayout(Math.max(3, Math.round(opts.cols)), Math.max(1, Math.round(opts.rows)), P) : octLayout(Math.max(2, Math.round(opts.cols)), P);
+  const { width: AW, height: AH, frames } = layout;
+  const crown = [0, 0.6 * height, 0];
+  const frameOf = new Int32Array(AW * AH).fill(-1);
+  let span = 0;
+  frames.forEach((f, fi) => {
+    span = Math.max(span, f.x1 - f.x0, f.y1 - f.y0);
+    for (let y = f.y0;y < f.y1; y++)
+      frameOf.fill(fi, y * AW + f.x0, y * AW + f.x1);
+  });
+  const base = new Uint8Array(AW * AH * 4), data = new Uint8Array(AW * AH * 4), covered = new Uint8Array(AW * AH);
+  const samples = span * span * 4;
+  const zb = new Float32Array(samples), tb = new Int32Array(samples), l1b = new Float32Array(samples), l2b = new Float32Array(samples);
+  const qx = new Float32Array(nv), qy = new Float32Array(nv), qz = new Float32Array(nv);
+  for (const fr of frames) {
+    const d = fr.d;
+    const { right, up } = frameBasis(d);
+    const { x0: X0, x1: X1, y0: Y0, y1: Y1 } = fr;
+    const W = (X1 - X0) * 2, H = (Y1 - Y0) * 2;
+    const k = 0.5 / r;
+    for (let v = 0;v < nv; v++) {
+      const dx = pos[v * 3] - c[0], dy = pos[v * 3 + 1] - c[1], dz = pos[v * 3 + 2] - c[2];
+      const a = 0.5 + k * (dx * right[0] + dy * right[1] + dz * right[2]);
+      const b = 0.5 + k * (dx * up[0] + dy * up[1] + dz * up[2]);
+      qx[v] = a * W;
+      qy[v] = (1 - b) * H;
+      qz[v] = dx * d[0] + dy * d[1] + dz * d[2];
+    }
+    zb.fill(-Infinity, 0, W * H);
+    tb.fill(-1, 0, W * H);
+    for (let t = 0;t < nt; t++) {
+      const ia = tri[t * 3], ib = tri[t * 3 + 1], ic = tri[t * 3 + 2];
+      const x0 = qx[ia], y0 = qy[ia], x1 = qx[ib], y1 = qy[ib], x2 = qx[ic], y2 = qy[ic];
+      const minX = Math.max(0, Math.ceil(Math.min(x0, x1, x2) - 0.5)), maxX = Math.min(W - 1, Math.floor(Math.max(x0, x1, x2) - 0.5));
+      if (minX > maxX)
+        continue;
+      const minY = Math.max(0, Math.ceil(Math.min(y0, y1, y2) - 0.5)), maxY = Math.min(H - 1, Math.floor(Math.max(y0, y1, y2) - 0.5));
+      if (minY > maxY)
+        continue;
+      const area = (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0);
+      if (Math.abs(area) < 0.000000000001)
+        continue;
+      const slot = slots[triSlot[t]];
+      if (slot.cull && face[t * 3] * d[0] + face[t * 3 + 1] * d[1] + face[t * 3 + 2] * d[2] < 0)
+        continue;
+      const inv = 1 / area;
+      const z0 = qz[ia], dz1 = qz[ib] - z0, dz2 = qz[ic] - z0;
+      const testAlpha = slot.mask;
+      const u0 = uv[ia * 2], v0 = uv[ia * 2 + 1], du1 = uv[ib * 2] - u0, dv1 = uv[ib * 2 + 1] - v0, du2 = uv[ic * 2] - u0, dv2 = uv[ic * 2 + 1] - v0;
+      const s1x = (y2 - y0) * inv, s2x = -(y1 - y0) * inv;
+      for (let sy = minY;sy <= maxY; sy++) {
+        const py = sy + 0.5 - y0, px = minX + 0.5 - x0;
+        let l1 = (px * (y2 - y0) - py * (x2 - x0)) * inv;
+        let l2 = ((x1 - x0) * py - (y1 - y0) * px) * inv;
+        const row = sy * W;
+        for (let sx = minX;sx <= maxX; sx++, l1 += s1x, l2 += s2x) {
+          if (l1 < -0.0000001 || l2 < -0.0000001 || l1 + l2 > 1.0000001)
+            continue;
+          const z = z0 + l1 * dz1 + l2 * dz2;
+          const s = row + sx;
+          if (z <= zb[s])
+            continue;
+          if (testAlpha && alphaAt(slot, u0 + l1 * du1 + l2 * du2, v0 + l1 * dv1 + l2 * dv2) < slot.cutoff)
+            continue;
+          zb[s] = z;
+          tb[s] = t;
+          l1b[s] = l1;
+          l2b[s] = l2;
+        }
+      }
+    }
+    for (let y = Y0;y < Y1; y++) {
+      for (let x = X0;x < X1; x++) {
+        let n = 0, cr = 0, cg = 0, cb = 0, nx = 0, ny = 0, nz = 0, aoSum = 0, zSum = 0;
+        for (let q = 0;q < 4; q++) {
+          const s = ((y - Y0) * 2 + (q >> 1)) * W + (x - X0) * 2 + (q & 1);
+          const t = tb[s];
+          if (t < 0)
+            continue;
+          zSum += zb[s];
+          const l1 = l1b[s], l2 = l2b[s], l0 = 1 - l1 - l2;
+          const ia = tri[t * 3], ib = tri[t * 3 + 1], ic = tri[t * 3 + 2];
+          const mx = pos[ia * 3] * l0 + pos[ib * 3] * l1 + pos[ic * 3] * l2 - crown[0];
+          const my = pos[ia * 3 + 1] * l0 + pos[ib * 3 + 1] * l1 + pos[ic * 3 + 1] * l2 - crown[1];
+          const mz = pos[ia * 3 + 2] * l0 + pos[ib * 3 + 2] * l1 + pos[ic * 3 + 2] * l2 - crown[2];
+          const ml = Math.hypot(mx, my, mz) || 1;
+          nx += mx / ml;
+          ny += my / ml;
+          nz += mz / ml;
+          const slot = slots[triSlot[t]];
+          if (slot.img) {
+            taps(slot, uv[ia * 2] * l0 + uv[ib * 2] * l1 + uv[ic * 2] * l2, uv[ia * 2 + 1] * l0 + uv[ib * 2 + 1] * l1 + uv[ic * 2 + 1] * l2);
+            const im = slot.img;
+            let r0 = 0, g0 = 0, b0 = 0;
+            for (let k4 = 0;k4 < 4; k4++) {
+              const o = tapI[k4], w = tapW[k4];
+              r0 += SRGB_TO_LINEAR2[im[o]] * w;
+              g0 += SRGB_TO_LINEAR2[im[o + 1]] * w;
+              b0 += SRGB_TO_LINEAR2[im[o + 2]] * w;
+            }
+            cr += r0 * slot.f[0];
+            cg += g0 * slot.f[1];
+            cb += b0 * slot.f[2];
+          } else {
+            cr += slot.f[0];
+            cg += slot.f[1];
+            cb += slot.f[2];
+          }
+          aoSum += ao[ia] * l0 + ao[ib] * l1 + ao[ic] * l2;
+          n++;
+        }
+        if (!n)
+          continue;
+        const o = (y * AW + x) * 4;
+        covered[y * AW + x] = 1;
+        base[o] = toSrgb8(cr / n);
+        base[o + 1] = toSrgb8(cg / n);
+        base[o + 2] = toSrgb8(cb / n);
+        base[o + 3] = Math.round(n / 4 * 255);
+        const nl = Math.hypot(nx, ny, nz) || 1;
+        const [eu, ev] = normalEncode([nx / nl, ny / nl, nz / nl]);
+        const depth = zSum / n / r;
+        data[o] = Math.round(Math.min(Math.max(eu, 0), 1) * 255);
+        data[o + 1] = Math.round(Math.min(Math.max(ev, 0), 1) * 255);
+        data[o + 2] = Math.round(Math.min(Math.max(depth * 0.5 + 0.5, 0), 1) * 255);
+        data[o + 3] = Math.round(Math.min(Math.max(aoSum / n, 0), 1) * 255);
+      }
+    }
+  }
+  dilate(base, data, covered, AW, AH, frameOf, frames.length);
+  const root = g.root;
+  const rootName = root.getName() || root.getMesh()?.getName() || "impostor";
+  let highest = 0;
+  for (const n of doc.getRoot().listNodes()) {
+    const m = LOD_RE.exec(n.getName());
+    if (m)
+      highest = Math.max(highest, Number(m[1]));
+  }
+  const level = Math.min(Math.max(1, Math.round(opts.level ?? 2)), highest + 1);
+  const drop = (n) => {
+    for (const ch of n.listChildren())
+      drop(ch);
+    n.dispose();
+  };
+  for (const n of doc.getRoot().listNodes()) {
+    const m = LOD_RE.exec(n.getName());
+    if (m && Number(m[1]) >= level && !n.isDisposed())
+      drop(n);
+  }
+  const buffer = doc.getRoot().listBuffers()[0] ?? doc.createBuffer();
+  const tag = () => ({ lecodes: { impostor: true } });
+  const albedo = doc.createTexture(`${rootName}_impostor_albedo`).setMimeType("image/png").setImage(await encodePng2(base, AW, AH)).setExtras(tag());
+  const normalDepth = doc.createTexture(`${rootName}_impostor_data`).setMimeType("image/png").setImage(await encodePng2(data, AW, AH)).setExtras(tag());
+  const material = doc.createMaterial(`${rootName}_impostor`).setAlphaMode("MASK").setAlphaCutoff(0.5).setDoubleSided(true).setMetallicFactor(0).setRoughnessFactor(1).setBaseColorFactor([1, 1, 1, 1]).setBaseColorTexture(albedo).setMetallicRoughnessTexture(normalDepth).setExtras({ lecodes: { impostor: [layout.cols, c[0], c[1], c[2], r, layout.rows] } });
+  for (const info of [material.getBaseColorTextureInfo(), material.getMetallicRoughnessTextureInfo()])
+    info?.setWrapS(CLAMP).setWrapT(CLAMP);
+  const acc = (type, arr) => doc.createAccessor().setType(type).setArray(arr).setBuffer(buffer);
+  const corners = new Float32Array([-1, -1, -1, 1, -1, 1, 1, 1, -1, -1, 1, 1]).map((s, k) => c[k % 3] + s * r);
+  const prim = doc.createPrimitive().setMaterial(material).setAttribute("POSITION", acc("VEC3", corners)).setAttribute("NORMAL", acc("VEC3", new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1]))).setAttribute("TEXCOORD_0", acc("VEC2", new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]))).setAttribute("COLOR_0", acc("VEC4", new Float32Array(16).fill(1))).setIndices(acc("SCALAR", new Uint16Array([0, 1, 2, 0, 2, 3])));
+  const node = doc.createNode(`${rootName}_LOD${level}`).setMesh(doc.createMesh(`${rootName}_impostor`).addPrimitive(prim)).setExtras({ lecodes: { impostor: { cols: layout.cols, rows: layout.rows, px: P } } });
+  const parent = root.getParentNode();
+  if (parent) {
+    parent.addChild(node);
+    const pw = parent.getWorldMatrix();
+    const identity = pw.every((x, k) => Math.abs(x - (k % 5 === 0 ? 1 : 0)) < 0.000001);
+    const inv = identity ? null : invert4(pw);
+    if (inv)
+      node.setMatrix(inv);
+  } else {
+    for (const s of doc.getRoot().listScenes())
+      if (s.listChildren().includes(root))
+        s.addChild(node);
+  }
+  const logger = doc.getLogger();
+  doc.setLogger(new Logger3(Logger3.Verbosity.SILENT));
+  await doc.transform(prune3({
+    propertyTypes: [PropertyType.MESH, PropertyType.PRIMITIVE, PropertyType.MATERIAL, PropertyType.TEXTURE, PropertyType.ACCESSOR],
+    keepLeaves: true,
+    keepAttributes: true,
+    keepIndices: true,
+    keepSolidTextures: true,
+    keepExtras: false
+  }));
+  doc.setLogger(logger);
+  return { cols: layout.cols, rows: layout.rows, px: P, width: AW, height: AH, radius: r, center: c, level, triangles: nt, ms: Math.round(performance.now() - t0), node: node.getName() };
+};
+var init_impostor = __esm(() => {
+  init_image();
+  LOD_RE = /_LOD([1-9]\d*)$/i;
+  SRGB_TO_LINEAR2 = Float32Array.from({ length: 256 }, (_, i) => {
+    const c = i / 255;
+    return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  });
+  tapI = new Int32Array(4);
+  tapW = new Float32Array(4);
+});
+
 // src/geometry.ts
 var MAX_VERTICES = 65535, mul32 = (m, x, y, z, w) => [
   m[0] * x + m[4] * y + m[8] * z + m[12] * w,
@@ -13840,20 +14428,33 @@ var cloneTree = (t) => {
         x.children.forEach(collect);
       };
       collect(g);
+      const levels = c.body.m_LODs.filter((lod) => isMap(lod) && Array.isArray(lod.renderers)).length;
       c.body.m_LODs.forEach((lod, level) => {
         if (!isMap(lod) || !Array.isArray(lod.renderers))
           return;
         for (const r of lod.renderers) {
           const id = ref(isMap(r) ? r.renderer : undefined).fileID;
           const rc = byId.get(id) ?? ids?.get(id);
-          if (rc && "go" in rc && !out.has(rc))
-            out.set(rc, level);
+          if (!rc || !("go" in rc))
+            continue;
+          if (levels <= 1) {
+            if (!out.has(rc))
+              out.set(rc, []);
+            continue;
+          }
+          const have = out.get(rc);
+          if (!have)
+            out.set(rc, [level]);
+          else if (have.length > 0 && !have.includes(level))
+            have.push(level);
         }
       });
     }
     g.children.forEach(walk);
   };
   roots.forEach(walk);
+  for (const v of out.values())
+    v.sort((a, b) => a - b);
   return out;
 };
 var init_gameObjects = () => {};
@@ -14986,6 +15587,7 @@ var readCollider = (c, path, M) => {
   };
   const kindOf = (root, prefab, fallbackName, nested) => {
     const parts = [], colliders = [], klights = [];
+    const drawn = [];
     let particles = 0;
     const lods = lodLevels([root]);
     const walk = (g, parentM, path, top) => {
@@ -15004,7 +15606,9 @@ var readCollider = (c, path, M) => {
         const mesh = ref(mf.body.m_Mesh);
         if (mesh.guid && mesh.guid !== "0000000000000000e000000000000000") {
           const mats = Array.isArray(mr.body.m_Materials) ? mr.body.m_Materials.map((x) => ref(x).guid ?? "") : [];
-          parts.push({ path: p, matrix: M, mesh: { guid: mesh.guid, fileID: mesh.fileID }, materials: mats, lod: lods.get(mr) ?? lodSuffix(goName(g)), castShadows: num2(mr.body.m_CastShadows, 1) !== 0 });
+          const suffix = lodSuffix(goName(g));
+          const levels = lods.get(mr) ?? (suffix > 0 ? [suffix] : []);
+          drawn.push({ part: { path: p, matrix: M, mesh: { guid: mesh.guid, fileID: mesh.fileID }, materials: mats, castShadows: num2(mr.body.m_CastShadows, 1) !== 0 }, levels });
         }
       }
       for (const c of g.comps) {
@@ -15022,6 +15626,12 @@ var readCollider = (c, path, M) => {
         walk(ch, m, p, false);
     };
     walk(root, I42(), "", true);
+    const maxLevel = drawn.reduce((m, d) => Math.max(m, ...d.levels), 0);
+    for (const d of drawn) {
+      const levels = d.levels.length ? d.levels : Array.from({ length: maxLevel + 1 }, (_, i) => i);
+      for (const lod of levels)
+        parts.push({ ...d.part, lod });
+    }
     stats.particles += particles;
     stats.prefabLights += klights.length;
     if (!parts.length && !colliders.length)
@@ -15462,8 +16072,8 @@ var EPS2 = 0.000000001, rotate = (q, v) => {
 };
 
 // src/unity/triBudget.ts
-import { PropertyType } from "@gltf-transform/core";
-import { prune as prune3, simplifyPrimitive as simplifyPrimitive2, weldPrimitive as weldPrimitive3 } from "@gltf-transform/functions";
+import { PropertyType as PropertyType2 } from "@gltf-transform/core";
+import { prune as prune4, simplifyPrimitive as simplifyPrimitive2, weldPrimitive as weldPrimitive3 } from "@gltf-transform/functions";
 import { MeshoptSimplifier as MeshoptSimplifier2 } from "meshoptimizer";
 var DEFAULT_MAX_TRIS = 50000, trisOf = (p) => p.getMode() !== 4 ? 0 : Math.floor((p.getIndices()?.getCount() ?? p.getAttribute("POSITION")?.getCount() ?? 0) / 3), fitTriangleBudget = async (doc, maxTris) => {
   const prims = [...new Set(doc.getRoot().listMeshes().flatMap((m) => m.listPrimitives()))].filter((p) => p.getMode() === 4 && !p.getAttribute("JOINTS_0"));
@@ -15483,7 +16093,7 @@ var DEFAULT_MAX_TRIS = 50000, trisOf = (p) => p.getMode() !== 4 ? 0 : Math.floor
       smoothNormals(doc, p);
     }
   }
-  await doc.transform(prune3({ propertyTypes: [PropertyType.ACCESSOR] }));
+  await doc.transform(prune4({ propertyTypes: [PropertyType2.ACCESSOR] }));
   return { before, after: prims.reduce((n, p) => n + trisOf(p), 0) };
 }, smoothNormals = (doc, p) => {
   const pos = p.getAttribute("POSITION"), idx = p.getIndices();
@@ -15804,7 +16414,7 @@ var init_triplanar = __esm(() => {
 import { basename as basename21, dirname as dirname12 } from "node:path";
 import { readFileSync as readFileSync24 } from "node:fs";
 import { Document as Document5 } from "@gltf-transform/core";
-import { mergeDocuments as mergeDocuments2, prune as prune4 } from "@gltf-transform/functions";
+import { mergeDocuments as mergeDocuments2, prune as prune5 } from "@gltf-transform/functions";
 
 class KindGlbBuilder {
   ctx;
@@ -16082,7 +16692,7 @@ class KindGlbBuilder {
         s.dispose();
     for (const n of out.imported)
       n.dispose();
-    await doc.transform(prune4({ keepLeaves: false }));
+    await doc.transform(prune5({ keepLeaves: false }));
     const buffers = doc.getRoot().listBuffers();
     if (buffers.length > 1) {
       const keep = buffers[0];
@@ -16399,24 +17009,31 @@ var planLayers = async (t) => {
   if (!t || !r.terrain)
     return null;
   mkdirSync5(dir, { recursive: true });
-  const res = t.resolution;
+  const src = t.resolution;
+  let step = 1;
+  if (opts.terrainRes && opts.terrainRes > 1)
+    while ((src - 1) / step + 1 > opts.terrainRes && (src - 1) % (step * 2) === 0)
+      step *= 2;
+  const res = (src - 1) / step + 1;
+  if (step > 1)
+    log(`   \uD83C\uDFD4  terrain heightfield ${src}² → ${res}² (every ${step}th sample, --terrain-res ${opts.terrainRes})`);
   const heights = new Float32Array(res * res);
   for (let z = 0;z < res; z++)
     for (let x = 0;x < res; x++)
-      heights[z * res + x] = t.heights[z * res + (res - 1 - x)];
+      heights[z * res + x] = t.heights[z * step * src + (src - 1 - x * step)];
   const plan = await planLayers(t);
   const slot = new Map;
   plan.keep.forEach((li, s) => slot.set(li, s));
   for (const [lose, win] of plan.mergeInto)
     slot.set(lose, slot.get(win));
   const ar = t.alphaResolution, control = new Uint8Array(res * res * 4);
-  const f = ar / res;
+  const f = ar / src;
   for (let z = 0;z < res; z++)
     for (let x = 0;x < res; x++) {
-      const ux = res - 1 - x;
+      const ux = (res - 1 - x) * step, uz = z * step;
       const acc = [0, 0, 0, 0];
-      const ax0 = Math.max(0, Math.floor((ux - 0.5) * f)), ax1 = Math.min(ar - 1, Math.ceil((ux + 0.5) * f));
-      const az0 = Math.max(0, Math.floor((z - 0.5) * f)), az1 = Math.min(ar - 1, Math.ceil((z + 0.5) * f));
+      const ax0 = Math.max(0, Math.floor((ux - step / 2) * f)), ax1 = Math.min(ar - 1, Math.ceil((ux + step / 2) * f));
+      const az0 = Math.max(0, Math.floor((uz - step / 2) * f)), az1 = Math.min(ar - 1, Math.ceil((uz + step / 2) * f));
       for (let li = 0;li < t.weights.length; li++) {
         const w = t.weights[li];
         let s = 0;
@@ -16549,12 +17166,15 @@ var buildBvh = (tris) => {
     }
   }
   return best;
-}, LOD_RE, collectOccluders = (doc) => {
+}, LOD_RE2, windProfiled = (p) => {
+  const extras = p.getMaterial()?.getExtras();
+  return Array.isArray(extras?.lecodes?.wind);
+}, collectOccluders = (doc) => {
   const tris = [];
   const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
   for (const node of doc.getRoot().listNodes()) {
     const mesh = node.getMesh();
-    if (!mesh || LOD_RE.test(node.getName()))
+    if (!mesh || LOD_RE2.test(node.getName()))
       continue;
     const m = node.getWorldMatrix();
     for (const p of mesh.listPrimitives()) {
@@ -16609,7 +17229,7 @@ var buildBvh = (tris) => {
   if (canopy > 0) {
     for (const node of doc.getRoot().listNodes()) {
       const mesh = node.getMesh();
-      if (!mesh || LOD_RE.test(node.getName()))
+      if (!mesh || LOD_RE2.test(node.getName()))
         continue;
       const m = node.getWorldMatrix();
       for (const p of mesh.listPrimitives()) {
@@ -16649,7 +17269,7 @@ var buildBvh = (tris) => {
       const n = pos.getCount();
       const nrm = p.getAttribute("NORMAL");
       if (canopy > 0 && crownN && nrm && p.getMaterial()?.getAlphaMode() === "MASK") {
-        const inv = invert4(m);
+        const inv = invert42(m);
         const cl = inv ? [inv[0] * crown[0] + inv[4] * crown[1] + inv[8] * crown[2] + inv[12], inv[1] * crown[0] + inv[5] * crown[1] + inv[9] * crown[2] + inv[13], inv[2] * crown[0] + inv[6] * crown[1] + inv[10] * crown[2] + inv[14]] : null;
         if (cl) {
           const out = new Float32Array(new ArrayBuffer(n * 12)), v = [], q = [];
@@ -16675,6 +17295,7 @@ var buildBvh = (tris) => {
       }
       const old = p.getAttribute("COLOR_0");
       const oldEl = old ? old.getElementSize() : 0;
+      const authoredWind = windProfiled(p);
       const out = new Float32Array(new ArrayBuffer(n * 16));
       const v = [], c = [], q = [];
       const cavNrm = cavReach > 0 && p.getMaterial()?.getAlphaMode() !== "MASK" ? p.getAttribute("NORMAL") : null;
@@ -16710,7 +17331,7 @@ var buildBvh = (tris) => {
           cav = 1 - occ / cavRays.length;
         }
         let wind;
-        if (old && oldEl === 4) {
+        if (old && oldEl === 4 && authoredWind) {
           old.getElement(i, c);
           wind = c[3];
         } else {
@@ -16738,7 +17359,7 @@ var buildBvh = (tris) => {
   q[0] = x / l;
   q[1] = y / l;
   q[2] = z / l;
-}, invert4 = (m) => {
+}, invert42 = (m) => {
   const a = Array.from(m), r = new Array(16);
   const [a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23, a30, a31, a32, a33] = a;
   const b00 = a00 * a11 - a01 * a10, b01 = a00 * a12 - a02 * a10, b02 = a00 * a13 - a03 * a10, b03 = a01 * a12 - a02 * a11;
@@ -16767,14 +17388,14 @@ var buildBvh = (tris) => {
   return r;
 };
 var init_vertexAo = __esm(() => {
-  LOD_RE = /_LOD([1-9]\d*)$/i;
+  LOD_RE2 = /_LOD([1-9]\d*)$/i;
 });
 
 // src/unity/lecodesLevel.ts
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync24, mkdirSync as mkdirSync6, readFileSync as readFileSync27, writeFileSync as writeFileSync12 } from "node:fs";
 import { dirname as dirname13, join as join12, relative, resolve as resolve6 } from "node:path";
-var BUILDER_VERSION = 12, v3 = (v) => `[${v.map(r3).join(", ")}]`, ident = (s) => {
+var BUILDER_VERSION = 20, v3 = (v) => `[${v.map(r3).join(", ")}]`, ident = (s) => {
   const x = s.replace(/[^\w$]/g, "_");
   return /^\d/.test(x) ? `_${x}` : x;
 }, transformFields = (pos, rot, scale) => {
@@ -16852,7 +17473,7 @@ var BUILDER_VERSION = 12, v3 = (v) => `[${v.map(r3).join(", ")}]`, ident = (s) =
   if (foliage)
     model.push("foliage: true");
   if (noLightmap)
-    model.push("lightmap: false");
+    model.push("static: false");
   if (modelAspects.length)
     model.push(`aspects: [${modelAspects.join(", ")}]`);
   return `// Generated by \`lecodes assets scene\` from ${source}${k.prefabPath ? ` (${k.prefabPath.replace(/\\/g, "/").replace(/^.*\/Assets\//, "Assets/")})` : ""}.
@@ -16880,7 +17501,7 @@ ${[`    model: { ${model.join(", ")} },`, ...children].join(`
     const glb = join12(assetDir, `${k.name}.glb`);
     const maxTris = opts.maxTris ?? DEFAULT_MAX_TRIS;
     const foliage = decideFoliage(k, builder.materialsOf(k), opts);
-    const hash = createHash3("sha1").update(JSON.stringify([BUILDER_VERSION, k.key, opts.maxSize, opts.ktx2, maxTris, ...foliage ? [] : ["nocolor"]])).digest("hex").slice(0, 16);
+    const hash = createHash3("sha1").update(JSON.stringify([BUILDER_VERSION, k.key, opts.maxSize, opts.ktx2, maxTris, ...foliage ? [] : ["nocolor"], ...foliage && opts.impostor ? ["impostor", opts.impostor.cols, opts.impostor.rows, opts.impostor.px ?? 0, opts.impostor.level ?? 2] : []])).digest("hex").slice(0, 16);
     if (!opts.force && existsSync24(glb) && manifest[k.name] === hash) {
       reused++;
       continue;
@@ -16897,6 +17518,9 @@ ${[`    model: { ${model.join(", ")} },`, ...children].join(`
           }
         }
     if (foliage) {
+      for (const m of doc.getRoot().listMaterials())
+        if (m.getAlphaMode() === "MASK")
+          m.setDoubleSided(true);
       await Promise.resolve().then(() => init_vertexAo());
       const ao = bakeVertexAo(doc);
       if (ao.vertices)
@@ -16911,6 +17535,16 @@ ${[`    model: { ${model.join(", ")} },`, ...children].join(`
     const cut = await fitTriangleBudget(doc, maxTris);
     if (cut)
       log(`   ✂ ${k.name}: ${cut.before.toLocaleString("en")} → ${cut.after.toLocaleString("en")} triangles (--max-tris ${maxTris})`);
+    if (foliage && opts.impostor) {
+      await Promise.resolve().then(() => init_impostor());
+      const box = impostorBounds(doc);
+      const height = box ? box.max[1] - box.min[1] : 0;
+      if (height >= 4) {
+        const imp = await bakeImpostor(doc, { ...opts.impostor, log });
+        if (imp)
+          log(`   \uD83C\uDF32 ${k.name}: impostor ${impostorLabel(imp)} · ${imp.node} · r ${imp.radius.toFixed(2)} m · ${imp.triangles} triangles in ${imp.ms} ms`);
+      }
+    }
     await applyPlan(doc, await analyzeDoc(doc, doctor), doctor);
     writeFileSync12(glb, await makeIO().writeBinary(doc));
     manifest[k.name] = hash;
@@ -16963,7 +17597,7 @@ ${[`    model: { ${model.join(", ")} },`, ...children].join(`
   }
   log(`   ${describeFoliage(foliageKinds, opts)}`);
   if (opts.noLightmap)
-    log(`   \uD83D\uDD26 lightmap: false on ${unbakedKinds.length} kind(s)${unbakedKinds.length ? `: ${unbakedKinds.slice(0, 8).join(", ")}${unbakedKinds.length > 8 ? " …" : ""}` : ` (nothing matched /${opts.noLightmap.source}/)`}`);
+    log(`   \uD83D\uDD26 static: false on ${unbakedKinds.length} kind(s)${unbakedKinds.length ? `: ${unbakedKinds.slice(0, 8).join(", ")}${unbakedKinds.length > 8 ? " …" : ""}` : ` (nothing matched /${opts.noLightmap.source}/)`}`);
 }, terrainNode = (r, terrain, sdir) => {
   const data = r.terrainData;
   const layers = terrain.layers.map((f, i) => {
@@ -19461,6 +20095,28 @@ var resolveInputs = (args, ext = /\.glb$/i, skipGenerated = true) => {
   }
   return [...new Set(out)];
 };
+var impostorFlag = (v, level) => {
+  if (v === undefined)
+    return;
+  if (level !== undefined && (!Number.isInteger(level) || level < 1 || level > 3))
+    throw usageError(`--impostor-level wants 1, 2 or 3 — got "${level}"`);
+  const s = v.trim() || "12x3";
+  const bad = (why) => usageError(`--impostor wants <A>x<E>[@<px>] (azimuths ≥ 3, rows 1..8) or oct<N>[@<px>] (N 2..64), px 32..1024 a multiple of 4 — e.g. 12x3, 8x2@256, oct8@128 — got "${v}" (${why})`);
+  const grid = /^(\d+)x(\d+)(?:@(\d+))?$/i.exec(s), oct = /^oct(\d+)(?:@(\d+))?$/i.exec(s);
+  if (!grid && !oct)
+    throw bad("not either form");
+  const cols = Number(grid ? grid[1] : oct[1]), rows = grid ? Number(grid[2]) : 0;
+  const pxs = grid ? grid[3] : oct[2], px = pxs ? Number(pxs) : undefined;
+  if (grid && (cols < 3 || cols > 64))
+    throw bad("azimuths 3..64");
+  if (grid && (rows < 1 || rows > 8))
+    throw bad("rows 1..8");
+  if (oct && (cols < 2 || cols > 64))
+    throw bad("N 2..64");
+  if (px !== undefined && (px < 32 || px > 1024 || px % 4 !== 0))
+    throw bad("px 32..1024, a multiple of 4");
+  return { cols, rows, px, level };
+};
 var regexFlag = (v) => v ? new RegExp(v, "i") : undefined;
 
 // src/commands/avatar.ts
@@ -19756,7 +20412,9 @@ var doctor_default = defineCommand({
     dump: str("write the file's textures out instead (default: <in>-textures/)", { value: "dir", bare: "" }),
     ...doctorFlags,
     lod: str("add mesh LOD levels (<name>_LOD1… siblings at these triangle ratios, same skin; >= 2000-tri meshes only) — creator-gl shows one by screen size (docs/lod-plan.md)", { value: "0.5,0.2", group: "LOD" }),
-    "lod-bones": bool("fold fingers / toes / twists onto their parents in the last level's skin")
+    "lod-bones": bool("fold fingers / toes / twists onto their parents in the last level's skin"),
+    impostor: str("bake the level-0 geometry into an impostor atlas (albedo + hull normal / AO) and add it as a LOD level, one camera-facing quad (<name>_LOD<k>, k = --impostor-level, never past the first missing level; the levels from k up are replaced). PNG / JPEG base colours only — run it with --ktx2, not after it; the atlases skip --max-size. <A>x<E>[@<px>] = A azimuths × E elevation rows (0°, 90°/E, …; 8x2@256), oct<N>[@<px>] = the N×N hemi-octahedron (steep views too); bare = 12x3; px = a frame's pixels (default 256 for a plant ≥ 8 m, 128 under)", { value: "<A>x<E>[@px]|oct<N>[@px]", bare: "12x3" }),
+    "impostor-level": int("the LOD slot the quad takes (default 2: shown under 0.12 of the viewport height; 1 = under 0.30)")
   },
   examples: [
     "lecodes assets doctor hero.glb",
@@ -19772,7 +20430,8 @@ var doctor_default = defineCommand({
     await Promise.resolve().then(() => init_validateGlb());
     const useKtx2 = wantsKtx2(flags);
     const lod = (flags.lod ?? "").split(",").map(Number).filter((n) => n > 0 && n < 1);
-    const doFix = wantsDoctorFix(flags) || flags["fix-metallic"] || lod.length > 0;
+    const impostor = impostorFlag(flags.impostor, flags["impostor-level"]);
+    const doFix = wantsDoctorFix(flags) || flags["fix-metallic"] || lod.length > 0 || !!impostor;
     const opts = { ...doctorOptions(flags), lod, lodBones: flags["lod-bones"] };
     const ktxEncoder = useKtx2 ? findKtxEncoder() : null;
     if (useKtx2) {
@@ -19797,6 +20456,21 @@ var doctor_default = defineCommand({
         await dumpTextures(doc, flags.dump && files.length === 1 ? flags.dump : input.replace(/\.glb$/i, "-textures"));
         continue;
       }
+      if (impostor) {
+        await Promise.resolve().then(() => init_impostor());
+        try {
+          const imp = await bakeImpostor(doc, { ...impostor, log });
+          if (imp)
+            log(`   impostor: ${imp.node} · ${impostorLabel(imp)} · r ${imp.radius.toFixed(2)} m · ${imp.triangles} triangles in ${imp.ms} ms`);
+          else
+            log(`   impostor: no level-0 triangles in ${input}`);
+        } catch (e) {
+          console.error(`
+✗ ${input}: ${e.message}`);
+          exitCode = 1;
+          continue;
+        }
+      }
       const plan = await analyzeDoc(doc, opts);
       const rep = reportPlan(plan);
       log(`
@@ -20438,6 +21112,8 @@ var scene_default = defineCommand({
     "no-shadows": str("kinds whose name matches take 'castShadows: false': a pack's BACKGROUND MOUNTAINS are 2 km meshes a kilometre out that Unity's shadow distance never reaches, and here their shadow lies across the whole map", { value: "<re>" }),
     "no-colliders": bool("write NO colliders: the kinds are pure visuals, nothing gets a Physics body. For a viewer, or a level whose 78 000 placements would otherwise be 20 000 Jolt bodies before the game adds one of its own"),
     "max-tris": int("triangles a kind may have before the import simplifies it (default 50000, 0 = no cap): a photogrammetry scan otherwise arrives as a million-triangle prop AND mesh collider"),
+    impostor: str("foliage kinds ≥ 4 m tall get their far LOD level as ONE camera-facing quad over an atlas of views (albedo + hull normal / AO), replacing the pack's billboard; the atlases skip --max-size. <A>x<E>[@<px>] = A azimuths × E elevation rows (0°, 90°/E, …; 8x2@256), oct<N>[@<px>] = the N×N hemi-octahedron (steep views too); bare = 12x3; px = a frame's pixels (default 256 for a plant ≥ 8 m, 128 under)", { value: "<A>x<E>[@px]|oct<N>[@px]", bare: "12x3" }),
+    "impostor-level": int("the LOD slot the quad takes (default 2: shown under 0.12 of the viewport height; 1 = under 0.30, the pack's LOD1 goes; never past the first missing level)"),
     "no-trim-cards": bool("skip the alpha-card trim the import otherwise runs (it can empty a kind whose decal atlas is mostly clear)"),
     filter: str("keep only instances whose kind name / scene group / node name matches", { value: "<re>", group: "Subset" }),
     "drop-at": str(`leave OUT the placements standing at these points ("x,y,z;x,y,z", the lecodes frame the scene file prints, within 10 cm): the one instance of a kind the game moves while its twins stay put — the range's five lane targets, which Unity names like the sixth on a shelf`, { value: "<x,y,z;…>" }),
@@ -20445,6 +21121,7 @@ var scene_default = defineCommand({
     group: str("only instances under a scene group whose path contains this", { value: "name" }),
     region: str("only instances inside this Unity X/Z rectangle", { value: "x0,z0,x1,z1" }),
     "no-trees": bool("skip the terrain's painted trees"),
+    "terrain-res": num("the heightfield's largest resolution, samples a side — a finer Unity heightmap is read every k-th sample (Chernobyl's 4097² over 500 m: 12 cm cells, 117 MB, 33 M navmesh triangles; 1025 = half-metre cells; default 1025)", { value: "<n>" }),
     "no-details": bool("skip the terrain's detail meshes"),
     "include-inactive": bool("import inactive GameObjects too"),
     handedness: str("how Unity's left-handed frame is undone (default x: −x, (x, −y, −z, w))", { value: "x|none", group: "Source" }),
@@ -20500,6 +21177,8 @@ var scene_default = defineCommand({
         noColliders: flags["no-colliders"],
         noShadows: regexFlag(flags["no-shadows"]),
         maxTris: flags["max-tris"],
+        impostor: impostorFlag(flags.impostor, flags["impostor-level"]),
+        terrainRes: flags["terrain-res"] ?? 1025,
         command: "lecodes assets scene " + argv.map((a) => /[\s"'|<>^&();]/.test(a) ? `"${a.replace(/"/g, "\\\"")}"` : a).join(" ")
       });
       log(`\uD83D\uDCBE ${res.scene} — ${res.kinds} kinds (${res.converted} converted, ${res.reused} up to date), ${r.instances.length} placements, ${seconds(t0)}`);