lecodes-assets 2.4.10 → 2.5.0

package/src/doctor/transcodeKtx2.ts

@@ -4,6 +4,7 @@
 // Codec by texture role:
 //   - colour (base/emissive)            -> ETC1S, sRGB   (small, lossy)
 //   - data  (normal/metalRough/occ.)    -> UASTC + zstd, linear  (precise; ETC1S steps on a smooth channel)
+//   - an impostor atlas (either map)    -> UASTC + zstd (its colour is the far crown's hue; ETC1S shifts it)
 // …unless `codecPolicy: 'uastc'` asks for UASTC everywhere. That is for HERO assets — a
 // first-person weapon or gloves fill a third of the screen at 30 cm, where ETC1S's block artifacts
 // on the base colour are plainly visible. World props stay on the default: ETC1S is the right
@@ -16,7 +17,7 @@ import { existsSync, mkdtempSync, writeFileSync, readFileSync, rmSync } from 'no
 import { cpus, tmpdir } from 'node:os'
 import { join } from 'node:path'
 import type { Root, Texture } from '@gltf-transform/core'
-import { getTextureRoles, DEFAULT_MAX_SIZE } from './transcodeTextures'
+import { getTextureRoles, isImpostorAtlas, DEFAULT_MAX_SIZE } from './transcodeTextures'
 
 /**
  * The KTX2 encoder: KTX-Software's legacy `toktx`, or — when there is none — its unified `ktx`
@@ -143,12 +144,15 @@ export async function planKtx2(tex: Texture, root: Root, maxSize = DEFAULT_MAX_S
   // reflection probes, 2026-09-17) and it wrecks normals; colour stays on ETC1S (small, its artefacts hide in the
   // detail) unless 'uastc' asks for UASTC everywhere (hero assets). 'hq' is the same as the default now.
   // oetf: linear for any non-colour data.
+  // An impostor atlas (both maps) takes UASTC too: at the distance the quad shows, one texel is the whole screen pixel
+  // of a crown and ETC1S's palette quantisation shifts the crown's hue against the cards it replaces.
   const codec: 'etc1s' | 'uastc' =
     policy === 'uastc' ? 'uastc'
-    : isNormal || isData ? 'uastc'
+    : isNormal || isData || isImpostorAtlas(tex) ? 'uastc'
     : 'etc1s'
   const oetf: 'srgb' | 'linear' = isNormal || isData ? 'linear' : 'srgb'
-  const resize = Math.max(width, height) > maxSize
+  // an impostor atlas keeps its size whatever the cap (its frames are fixed pixel rects); still ×4 and mipmapped
+  const resize = !isImpostorAtlas(tex) && Math.max(width, height) > maxSize
   return {
     tex, name: tex.getName() || '?', roles, fromFmt, codec, oetf, resize, width, height, hasAlpha,
     beforeBytes: img.length, category: 'lossy',
@@ -250,7 +254,7 @@ async function encodeOne(plan: Ktx2Plan, enc: KtxEncoder, maxSize: number): Prom
     const snap4 = (n: number) => Math.max(4, Math.round(n / 4) * 4)
     let tw = plan.width, th = plan.height
     const m = Math.max(tw, th)
-    if (m > maxSize) { const s = maxSize / m; tw = tw * s; th = th * s }
+    if (plan.resize && m > maxSize) { const s = maxSize / m; tw = tw * s; th = th * s }
     tw = snap4(tw); th = snap4(th)
 
     let pipe = sharp(Buffer.from(plan.tex.getImage()!))

package/src/doctor/transcodeTextures.ts

@@ -15,6 +15,11 @@ import type { Root, Texture } from '@gltf-transform/core'
 export const DEFAULT_MAX_SIZE = 2048
 const HEAVY_PNG_MIN_DIM = 1024
 
+/** An IMPOSTOR ATLAS (doctor/impostor.ts tags both with extras `lecodes.impostor`): never resized by the size cap — its
+ *  frames sit at fixed pixel rects, and a 12 × 256 = 3072 px strip squashed under a 2048 cap is a different layout. */
+export const isImpostorAtlas = (tex: Texture): boolean =>
+  !!(tex.getExtras() as { lecodes?: { impostor?: unknown } } | undefined)?.lecodes?.impostor
+
 export interface TexturePlan {
   tex: Texture
   name: string
@@ -63,7 +68,7 @@ export async function planTexture(tex: Texture, root: Root, maxSize = DEFAULT_MA
     return null // undecodable by sharp — leave it
   }
 
-  const resize = Math.max(width, height) > maxSize
+  const resize = !isImpostorAtlas(tex) && Math.max(width, height) > maxSize
   let desired: 'jpeg' | 'png' = forceFmt ?? (hasAlpha ? 'png' : 'jpeg') // PNG only when alpha is needed
   if (desired === 'jpeg' && hasAlpha) desired = 'png' // never drop a real alpha channel
 

package/src/doctor/vertexAo.ts

@@ -7,8 +7,9 @@
 //   COLOR_0 = (ao, cavity, 1, wind)   ao      = sky visibility 0..1 (cosine-weighted upper hemisphere, WORLD up)
 //                                     cavity  = the bark's short-range occlusion 0..1 (the hemisphere of its own normal,
 //                                               hits within `cavity` metres: limb joints, the trunk under a limb); cards 1
-//                                     wind    = the per-vertex wind weight — the pack's own (COLOR_0.a as it came)
-//                                               or, for a mesh without one, the height over the plant squared
+//                                     wind    = the per-vertex wind weight — the pack's own (COLOR_0.a as it came) when
+//                                               its material carries a wind profile (`lecodes.wind`), else the height
+//                                               over the plant squared
 // An exact white (1, 1, 1, 1) is what gltfio hands a mesh WITHOUT a colour set, and the shader takes that
 // as "no data" (ao 1, height weight) — a vertex whose ao AND wind both round to 1 lands there too, and it
 // is exactly the vertex nothing changes for.
@@ -136,6 +137,13 @@ export type VertexAoOptions = {
 
 const LOD_RE = /_LOD([1-9]\d*)$/i
 
+/** True when the primitive's material carries the pack's wind profile (glTF extras `lecodes.wind`, kindGlb.ts
+ *  windProfile): the one case a vertex alpha is an authored wind weight. */
+const windProfiled = (p: Primitive): boolean => {
+  const extras = p.getMaterial()?.getExtras() as { lecodes?: { wind?: unknown } } | null | undefined
+  return Array.isArray(extras?.lecodes?.wind)
+}
+
 /** World-space triangles of every level-0 mesh node. */
 const collectOccluders = (doc: Document): { tris: Tri[], min: [number, number, number], max: [number, number, number] } => {
   const tris: Tri[] = []
@@ -247,6 +255,7 @@ export const bakeVertexAo = (doc: Document, opts: VertexAoOptions = {}): { verti
       }
       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: number[] = [], c: number[] = [], q: number[] = []
       // the cavity term: the bark (opaque) with a normal, rays in the hemisphere of the vertex' world normal
@@ -281,9 +290,12 @@ export const bakeVertexAo = (doc: Document, opts: VertexAoOptions = {}): { verti
           }
           cav = 1 - occ / cavRays.length
         }
-        // the wind weight: the pack's own (its alpha, as it came) or the height over the plant, squared
+        // the wind weight: the pack's own alpha when its shader AUTHORED one there (the material carries a wind profile,
+        // `lecodes.wind` - NatureManufacture paints the weight into the vertex alpha), else the height over the plant,
+        // squared. A pack whose wind mask lives in a texture (Chernobyl's Leaves.shader) ships the alpha at 1 everywhere,
+        // and taken as the weight that shivered every leaf by the field's full amplitude (2026-11-03).
         let wind: number
-        if (old && oldEl === 4) { old.getElement(i, c); wind = c[3] } else { const h = Math.min(Math.max((y - min[1]) / height, 0), 1); wind = h * h }
+        if (old && oldEl === 4 && authoredWind) { old.getElement(i, c); wind = c[3] } else { const h = Math.min(Math.max((y - min[1]) / height, 0), 1); wind = h * h }
         out[i * 4] = ao; out[i * 4 + 1] = cav; out[i * 4 + 2] = 1; out[i * 4 + 3] = wind
         sum += ao; vertices++
       }

package/src/unity/gameObjects.ts

@@ -55,9 +55,12 @@ export const localTRS = (go: UGO): TRS => {
 }
 export const enabled = (c: UComp): boolean => num(c.body.m_Enabled, 1) !== 0
 
-/** LOD level per renderer component (from every LODGroup in the tree): renderer → level. */
-export const lodLevels = (roots: UGO[], ids?: Map<string, UGO | UComp>): Map<UComp, number> => {
-  const out = new Map<UComp, number>()
+/** The LOD levels each renderer component is drawn at (from every LODGroup in the tree): renderer → its levels,
+ *  ascending. Unity lists a renderer under every level it serves (a door's LOD1 mesh standing in at LOD2 too), and a
+ *  renderer whose group has ONE level (a cull-only group: the walls of a composite building, each in a LODGroup of
+ *  its own) is drawn at every level — `[]` says so. A renderer in no LODGroup is not in the map. */
+export const lodLevels = (roots: UGO[], ids?: Map<string, UGO | UComp>): Map<UComp, number[]> => {
+  const out = new Map<UComp, number[]>()
   const walk = (g: UGO): void => {
     for (const c of g.comps) {
       if (c.cls !== "LODGroup" || !Array.isArray(c.body.m_LODs)) continue
@@ -65,17 +68,23 @@ export const lodLevels = (roots: UGO[], ids?: Map<string, UGO | UComp>): Map<UCo
       const byId = new Map<string, UComp>()
       const collect = (x: UGO): void => { for (const k of x.comps) byId.set(k.id, k); 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) as UComp | undefined)
-          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
 }

package/src/unity/lecodesLevel.ts

@@ -29,11 +29,14 @@ export type WriteLevelOptions = FoliageOptions & {
   force?: boolean
   maxSize?: number
   ktx2?: boolean
+  /** The heightfield's largest resolution (samples a side): a finer Unity heightmap is read every k-th sample
+   *  (levelTerrain.ts). Default 1025: half-metre cells over a 500 m map, the size every level so far ran on. */
+  terrainRes?: number
   log?: (s: string) => void
   /** Leave the pack's directional light out of the scene file: the level owns its sun — filament renders the
    *  brightest directional light of a scene and the bake follows it, so a second one only confuses. */
   noSun?: boolean
-  /** Kinds (by name) that take `lightmap: false` — no atlas rect, lit in real time. The case it was
+  /** Kinds (by name) that take `static: false` — no atlas rect, lit in real time. The case it was
    *  written for is a LAMP FIXTURE: the pack models the bulb inside its housing, so the fixture's own
    *  faces are the brightest texels in the level (the range's `SM_Door_lamp_a` read 18 000 lx against
    *  a 1 700 lx floor) and the bake spends a rect on each. Also the right switch for anything the game
@@ -63,6 +66,11 @@ export type WriteLevelOptions = FoliageOptions & {
   /** Triangles a kind may have before the import simplifies it (triBudget.ts; default 50 000, 0 = no cap):
    *  what keeps a photogrammetry scan from arriving as a million-triangle prop and mesh collider. */
   maxTris?: number
+  /** IMPOSTORS (doctor/impostor.ts): every foliage kind whose level-0 height is ≥ 4 m gets its far LOD level as one
+   *  camera-facing quad over an atlas of views — `cols` azimuths × `rows` elevation rows, or the N×N hemi-octahedron
+   *  of N = `cols` when `rows` is 0 — `px` pixels a frame (default 256 for a plant ≥ 8 m, 128 under), at LOD slot
+   *  `level` (default 2: the engine shows it under 0.12 of the viewport height; 1 = under 0.30, the pack's own LOD1 goes). */
+  impostor?: { cols: number, rows: number, px?: number, level?: number }
   /** The command that produced this import, written into the scene file's header. A re-import that
    *  forgets a flag silently undoes a decision — the dropped kinds come back, the lamps go into the
    *  atlas again — and nothing in the project records it, so the line IS the record. */
@@ -87,7 +95,17 @@ export type WriteLevelOptions = FoliageOptions & {
 //     `_ShiverDirectionality`) in the glTF material extras `lecodes.wind` (kindGlb.ts windProfile) — creator-gl's
 //     foliage tier bends and shivers each material as Unity HDRP's Wind.hlsl does.
 // 11: the bark's CAVITY occlusion in COLOR_0.g (vertexAo.ts `cavity`: short rays in the normal's hemisphere — limb joints).
-const BUILDER_VERSION = 12   // 12 (2026-10-18): a material without a metallic map or `_Metallic` is metallic 0, not glTF's 1 (the LOD3 crosses were black)
+// 12 (2026-10-18): a material without a metallic map or `_Metallic` is metallic 0, not glTF's 1 (the LOD3 crosses were black)
+// 13 (2026-11-03): an Amplify leaf graph's additive noise tint folds into the base colour factor (materialWriter.ts: Chernobyl's
+//     leaves drew at two thirds); the vertex alpha is the wind weight only under a `lecodes.wind` profile (vertexAo.ts)
+// 14 (2026-11-03): every MASK material of a vegetation kind is double-sided (a pack's leaf shader culls off in its source)
+// 15 (2026-11-03): `--impostor`: foliage kinds ≥ 4 m take an octahedral impostor quad as their last LOD level (doctor/impostor.ts)
+// 16 (2026-11-03): `--impostor-level`: the LOD slot the quad takes is the bake's choice (the engine's thresholds decide the distance)
+// 17 (2026-11-03): the impostor's data map carries the crown's HULL normal (xyz, the cards' shading normal), no depth
+// 18 (2026-11-03): `--impostor <A>x<E>[@px]`: azimuths × elevation rows (default 12x3), `oct<N>` keeps the octahedron; the atlases skip --max-size
+// 19 (2026-11-03): the impostor's albedo atlas is UASTC like its data map (ETC1S shifted the far crown's hue)
+// 20 (2026-11-03): the impostor's data map = octahedral hull normal (rg, object space) + depth (b) + AO (a): the quad self-shadows from its own atlas
+const BUILDER_VERSION = 20
 const v3 = (v: number[]): string => `[${v.map(r3).join(", ")}]`
 const ident = (s: string): string => { const x = s.replace(/[^\w$]/g, "_"); return /^\d/.test(x) ? `_${x}` : x }
 
@@ -171,7 +189,7 @@ const kindSceneFile = (k: SceneKind, glbRel: string, source: string, foliage: bo
   // the SDK's vegetation tier: wind, touch bending, per-copy tint (Foliage); a level may add `{ fade }` per kind
   if (foliage) model.push("foliage: true")
   // out of the bake entirely (`--no-lightmap <re>`): no atlas rect, lit in real time
-  if (noLightmap) model.push("lightmap: false")
+  if (noLightmap) 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/")})` : ""}.
 // Regenerated on every re-import — edit the level that instances it, not this file.
@@ -220,13 +238,16 @@ const buildKindGlbs = async (kinds: SceneKind[], builder: KindGlbBuilder, assetD
     // painted every broken branch pure red (2026-09-23). Non-foliage kinds lose COLOR_0; the vegetation
     // tier keeps it — its shader ignores the tint, and the alpha IS the wind weight it will read.
     const foliage = decideFoliage(k, builder.materialsOf(k), opts)
-    const hash = createHash("sha1").update(JSON.stringify([ BUILDER_VERSION, k.key, opts.maxSize, opts.ktx2, maxTris, ...(foliage ? [] : [ "nocolor" ]) ])).digest("hex").slice(0, 16)
+    const hash = createHash("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 && existsSync(glb) && manifest[k.name] === hash) { reused++; continue }
     const { doc, parts, missing } = await builder.build(k)
     if (!foliage) for (const m of doc.getRoot().listMeshes()) for (const p of m.listPrimitives()) { const c = p.getAttribute("COLOR_0"); if (c) { p.setAttribute("COLOR_0", null); if (c.listParents().length <= 1) c.dispose() } }
     // and the vegetation tier gets its VERTEX AO: the sky's visibility from every vertex baked into COLOR_0.r
     // (doctor/vertexAo.ts), the wind weight kept in the alpha — the one thing that makes a crown read as a volume
     if (foliage) {
+      // the cards of a plant are two-sided by nature; a pack's leaf shader may cull off in its SOURCE (Chernobyl's
+      // Leaves.shader: `Cull Off`), which no .mat property shows - the glTF flag says so for every reader (2026-11-03)
+      for (const m of doc.getRoot().listMaterials()) if (m.getAlphaMode() === "MASK") m.setDoubleSided(true)
       const { bakeVertexAo } = await import("../doctor/vertexAo")
       const ao = bakeVertexAo(doc)
       if (ao.vertices) log(`   🌿 ${k.name}: vertex AO on ${ao.vertices} vertices (mean ${ao.meanAo.toFixed(2)})`)
@@ -235,6 +256,18 @@ const buildKindGlbs = async (kinds: SceneKind[], builder: KindGlbBuilder, assetD
     if (!parts) { log(`   ⚠ ${k.name}: no mesh could be built — skipped`); continue }
     const cut = await fitTriangleBudget(doc, maxTris)
     if (cut) log(`   ✂ ${k.name}: ${cut.before.toLocaleString("en")} → ${cut.after.toLocaleString("en")} triangles (--max-tris ${maxTris})`)
+    // a TREE's far level as one quad over an atlas of views (doctor/impostor.ts) — before the doctor: the bake reads the
+    // PNG / JPEG base colours the KTX2 encode takes away, and the atlases go through that encode like any map
+    if (foliage && opts.impostor) {
+      const { bakeImpostor, impostorBounds, impostorLabel } = await import("../doctor/impostor")
+      const box = impostorBounds(doc)
+      const height = box ? box.max[1] - box.min[1] : 0
+      if (height >= 4) {
+        // px unset: the bake's own default by the same level-0 height (256 for ≥ 8 m, 128 under)
+        const imp = await bakeImpostor(doc, { ...opts.impostor, log })
+        if (imp) log(`   🌲 ${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)
     writeFileSync(glb, await makeIO().writeBinary(doc))
     manifest[k.name] = hash
@@ -287,7 +320,7 @@ const writeKindScenes = (kinds: SceneKind[], builder: KindGlbBuilder, dirs: { as
     log(`   🧱 collider fit (${r3(tol * 100)} cm): ${meshKinds.length} of ${boxKinds} kind(s) with box colliders take a MESH collider instead${meshKinds.length ? `: ${meshKinds.slice(0, 6).join(", ")}${meshKinds.length > 6 ? ` … +${meshKinds.length - 6}` : ""}` : ""}`)
   }
   log(`   ${describeFoliage(foliageKinds, opts)}`)
-  if (opts.noLightmap) log(`   🔦 lightmap: false on ${unbakedKinds.length} kind(s)${unbakedKinds.length ? `: ${unbakedKinds.slice(0, 8).join(", ")}${unbakedKinds.length > 8 ? " …" : ""}` : ` (nothing matched /${opts.noLightmap.source}/)`}`)
+  if (opts.noLightmap) log(`   🔦 static: false on ${unbakedKinds.length} kind(s)${unbakedKinds.length ? `: ${unbakedKinds.slice(0, 8).join(", ")}${unbakedKinds.length > 8 ? " …" : ""}` : ` (nothing matched /${opts.noLightmap.source}/)`}`)
 }
 
 // ---- the map scene -----------------------------------------------------------------------------------------

package/src/unity/levelTerrain.ts

@@ -67,26 +67,35 @@ const writeTerrainFile = (file: string, sizeX: number, sizeZ: number, cellSize:
 /** The `.terrain` file, the packed albedo file per kept layer, and the packed normal textures. */
 export type WrittenTerrain = { file: string, layers: string[], normals: string[] }
 
-export const writeTerrain = async (r: SceneImportFull, dir: string, name: string, opts: { ktx2?: boolean }, log: (s: string) => void): Promise<WrittenTerrain | null> => {
+export const writeTerrain = async (r: SceneImportFull, dir: string, name: string, opts: { ktx2?: boolean, terrainRes?: number }, log: (s: string) => void): Promise<WrittenTerrain | null> => {
   const t = r.terrainData
   if (!t || !r.terrain) return null
   mkdirSync(dir, { recursive: true })
-  const res = t.resolution
+  // THE HEIGHTFIELD'S RESOLUTION IS A COST EVERYWHERE: the file (7 bytes a sample), Jolt's height field, the navmesh's
+  // input (two triangles a cell: Chernobyl's 4097² = 33 M triangles, past what Recast's wasm can hold) and the render
+  // chunks. A pack's terrain is authored at Unity's 4097 over 500 m (12 cm cells) where half-metre cells draw the same
+  // ground; `--terrain-res` caps it: every k-th sample along both axes (the samples are exact, no filtering), the
+  // largest k whose result is at most the cap — a Unity heightmap is 2^n + 1, so every power of two divides it.
+  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(`   🏔  terrain heightfield ${src}² → ${res}² (every ${step}th sample, --terrain-res ${opts.terrainRes})`)
   // mirror the columns: LeCodes sample (0,0) is the Unity terrain's +X far corner
   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)]
+  for (let z = 0; z < res; z++) for (let x = 0; x < res; x++) heights[z * res + x] = t.heights[(z * step) * src + (src - 1 - x * step)]
   const plan = await planLayers(t)
   const slot = new Map<number, number>()
   plan.keep.forEach((li, s) => slot.set(li, s))
   for (const [ lose, win ] of plan.mergeInto) slot.set(lose, slot.get(win)!)
   // control: area-average the (finer) alphamaps onto the samples
   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                                                    // mirrored column
+    const ux = (res - 1 - x) * step, uz = z * step                             // mirrored column, in source samples
     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

package/src/unity/materialWriter.ts

@@ -96,7 +96,17 @@ export const unityMaterialWriter = (doc: Document, resolver: GuidResolver, warn:
     // tree-billboard shader's `_BaseColor` names a deleted file, its atlas sits in `_MainTex1`)
     const baseG = SLOTS.base.map((n) => um.textures[n]).find((g) => g && (g.startsWith(PATH_GUID) || resolver.resolve(g))) ?? null
     if (baseG) { const t = await texFromGuid(baseG); if (t) { gm.setBaseColorTexture(t); slots.push(`base=${nameOf(baseG)}`) } }
-    const baseColor = um.colors._BaseColor ?? um.colors._Color
+    let baseColor = um.colors._BaseColor ?? um.colors._Color
+    // An Amplify leaf graph's albedo is `_Color × tex + _Color_Tilling × tex × noise` (Chernobyl's Leaves.shader: a
+    // world-noise patchiness, noise 0..1): the mean of that is `_Color + _Color_Tilling / 2` on the texture, and
+    // `_Color` alone drew every leaf of the pack at two thirds of its brightness (2026-11-03). The patchiness itself
+    // is the vegetation shader's own (foliage.mat's leaf tint noise).
+    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] ])
     // EVERY slot is picked the way the base is: the first candidate whose texture EXISTS. A `.mat` keeps the
     // property block of every shader it ever wore, so a NatureManufacture bark that moved from HDRP Lit to

package/src/unity/scene.ts

@@ -32,7 +32,10 @@ export type KindPart = {
   mesh: { guid: string, fileID: string }
   /** `.mat` GUIDs, one per submesh (Unity's order). */
   materials: string[]
-  /** LODGroup level (0 when the renderer is in no LODGroup). */
+  /** The level this part is drawn at. THE ENGINE'S LOD GROUP IS THE WHOLE GLB (creator-gl lod.cpp): at level n it draws
+   *  the `_LOD<n>` nodes and nothing else, so a renderer Unity draws at several levels (listed under each, or in a
+   *  cull-only LODGroup, or in none while the kind has levels) is written once per level — the same mesh under a
+   *  node per level. One part here is one node. */
   lod: number
   castShadows: boolean
 }
@@ -218,6 +221,8 @@ export const importUnityScene = async (scenePath: string, opts: ImportSceneOptio
   const lodSuffix = (n: string): number => { const m = /_LOD(\d+)$/i.exec(n); return m ? +m[1] : 0 }
   const kindOf = (root: UGO, prefab: string | null, fallbackName: string, nested: { g: UGO, local: Mat4 }[]): SceneKind | null => {
     const parts: KindPart[] = [], colliders: KindCollider[] = [], klights: KindLight[] = []
+    // a renderer and the levels it is drawn at: `[]` = every level the kind has (expanded once the kind's levels are known)
+    const drawn: { part: Omit<KindPart, "lod">, levels: number[] }[] = []
     let particles = 0
     const lods = lodLevels([ root ])
     const walk = (g: UGO, parentM: Mat4, path: string, top: boolean): void => {
@@ -232,7 +237,10 @@ export const importUnityScene = async (scenePath: string, opts: ImportSceneOptio
         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: num(mr.body.m_CastShadows, 1) !== 0 })
+          // in no LODGroup: a loose renderer named like its node (`…_LOD1`) keeps that level; a plain one is drawn at every level
+          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: num(mr.body.m_CastShadows, 1) !== 0 }, levels })
         }
       }
       for (const c of g.comps) {
@@ -245,6 +253,12 @@ export const importUnityScene = async (scenePath: string, opts: ImportSceneOptio
       for (const ch of g.children) walk(ch, m, p, false)
     }
     walk(root, I4(), "", true)
+    // the kind's levels: a part drawn at every level gets a node per level (the same mesh, `<name>_LOD<n>` beside `<name>`)
+    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) return null