lecodes-cli 1.0.0 → 2.0.1

package/src/project/ignore.ts

@@ -1,163 +1,164 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
-
-/*
- * `.lecodesignore` support — keeps scratch files (temp probes, render screenshots, logs) out of
- * `status` / `push` so they never land in a checkpoint. Syntax is a practical subset of .gitignore:
- *   - blank lines and `# comments` are skipped
- *   - `!pattern` re-includes something a previous pattern ignored
- *   - a trailing `/` matches directories only
- *   - a leading `/` (or any embedded `/`) anchors the pattern to the project root
- *   - `*` matches within a path segment, `**` across segments, `?` a single char
- *   - a slash-free pattern (e.g. `_*`, `*.png`) matches a basename at any depth
- *
- * IMPORTANT: ignores apply to UNTRACKED files only. A file already in the project (recorded in the
- * manifest) is always tracked, even if it matches a pattern — so ignoring `*.png` can never make an
- * existing image asset silently disappear from the project. Pruning happens in `scanLocal`.
- */
-
-export type IgnoreMatcher = (key: string, isDir: boolean) => boolean
-
-type Rule = { re: RegExp, negate: boolean, dirOnly: boolean }
-
-// Always applied, even with no .lecodesignore — only patterns that are never real project assets, so
-// they're safe as invisible defaults. Everything asset-shaped (*.png, *.json, …) is opt-in via the
-// file written at clone time (see DEFAULT_IGNORE_FILE). `.artifacts/` is `lecodes test`'s
-// failure-frame dump dir (tests/.artifacts/) — regenerated scratch, never a project asset.
-// `dist/` is `lecodes app build desktop`'s default output (<root>/dist/<slug>, appDesktop.ts) —
-// same class, but it must be ignored for a second, load-bearing reason: that folder holds a COPY of
-// the host's runtime assets (lit.filamat, uberarchive.bin, …). Collected as project assets they get
-// staged next to the bundle, and onFetchLocal searches the bundle's dir BEFORE the host's assets dir
-// (main.cpp) — so the copy shadows the host's own. Harmless while every host was OpenGL and the
-// bytes matched; fatal once a build output can come from the Vulkan host, where the shadowing
-// lit.filamat is SPIR-V and Filament aborts with "not built for any of the OpenGL backend's
-// supported shader languages".
-// `.env` / `.env.*`: the project's LECODES_* config (projectEnv.ts) — it holds tokens and keystore
-// passwords, so it never leaves the machine whatever .lecodesignore says.
-const BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store", ".artifacts/", "dist/", ".env", ".env.*"]
-
-/** Template `.lecodesignore` written on clone — the explicit, editable "what we don't push" list. */
-export const DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
-# Only untracked files are affected — assets already in the project stay tracked
-# even if they match a pattern. Built-in defaults (node_modules, _*, *.log, .artifacts)
-# always apply.
-
-# Render / preview outputs (the default \`lecodes render --png\` target)
-screenshot.png
-shots/
-
-# Design-board comments live on the platform; design/comments/ is the local mirror of the
-# open ones (\`lecodes design comments pull\`) — read by Claude, but pushing it back as
-# project files would only duplicate the database.
-design/comments/
-
-# Image & other binary assets ARE pushed by default — they're real project resources.
-# Uncomment a pattern below only if you want to keep some untracked ones out of pushes.
-# *.png
-
-# Local notes & dumps (uncomment to ignore)
-# *.json
-# notes.md
-`
-
-/** Translate a glob (one path segment's worth of `*`/`?`/`**`) into a regex fragment. */
-const translate = (glob: string): string => {
-  let re = ""
-  for (let i = 0; i < glob.length; i++) {
-    const ch = glob[i]
-    if (ch === "*") {
-      if (glob[i + 1] === "*") { re += ".*"; i++; if (glob[i + 1] === "/") i++ } // `**/` spans dirs
-      else re += "[^/]*"
-    } else if (ch === "?") re += "[^/]"
-    else if (ch === "/") re += "/"
-    else if ("\\^$.|+()[]{}".includes(ch)) re += "\\" + ch
-    else re += ch
-  }
-  return re
-}
-
-const compile = (raw: string): Rule | null => {
-  let p = raw.trim()
-  if (!p || p.startsWith("#")) return null
-  let negate = false
-  if (p.startsWith("!")) { negate = true; p = p.slice(1) }
-  let dirOnly = false
-  if (p.endsWith("/")) { dirOnly = true; p = p.slice(0, -1) }
-  const anchored = p.startsWith("/") || p.includes("/")
-  if (p.startsWith("/")) p = p.slice(1)
-  if (!p) return null
-  const body = translate(p)
-  // `(/.*)?$` lets a directory pattern also match files nested under it, matching gitignore behavior
-  // even without relying on directory pruning.
-  const re = anchored ? new RegExp("^/" + body + "(/.*)?$") : new RegExp("(^|/)" + body + "(/.*)?$")
-  return { re, negate, dirOnly }
-}
-
-const buildMatcher = (rules: Rule[]): IgnoreMatcher => (key, isDir) => {
-  let ignored = false
-  for (const r of rules) {
-    if (r.dirOnly && !isDir) continue // a `foo/` rule only matches dirs directly (files via prune)
-    if (r.re.test(key)) ignored = !r.negate
-  }
-  return ignored
-}
-
-/** Compile a standalone glob list (same syntax as .lecodesignore lines, including `!` re-includes)
- *  into a file-path matcher — used for app.json's `resources.remote` patterns. */
-export const buildGlobMatcher = (patterns: string[]): ((path: string) => boolean) => {
-  // Matching is over FILE paths — normalize `videos/` (dir-only, would match nothing here) to
-  // `videos`, whose `(/.*)?$` tail matches everything under the directory.
-  const rules = patterns.map((p) => compile(p.trim().replace(/\/+$/, ""))).filter((r): r is Rule => r !== null)
-  const match = buildMatcher(rules)
-  // Anchored rules compile to `^/…` — they expect the canonical leading-slash key form.
-  return (path) => match(path.startsWith("/") ? path : "/" + path, false)
-}
-
-/** Read `<root>/.lecodesignore` (if any) and combine with the built-in defaults into a matcher. */
-export const loadIgnore = (root: string): IgnoreMatcher => {
-  const lines = [...BUILTIN_PATTERNS]
-  const file = join(root, ".lecodesignore")
-  if (existsSync(file)) {
-    try { lines.push(...readFileSync(file, "utf8").split(/\r?\n/)) } catch { /* unreadable → defaults only */ }
-  }
-  const rules = lines.map(compile).filter((r): r is Rule => r !== null)
-  return buildMatcher(rules)
-}
-
-/** Write the template `.lecodesignore` if the project doesn't have one yet (used on clone). */
-export const writeDefaultIgnore = (root: string) => {
-  const file = join(root, ".lecodesignore")
-  if (!existsSync(file)) writeFileSync(file, DEFAULT_IGNORE_FILE)
-}
-
-/* `.gitignore` for the project's OWN git repo. `.lecodes/` is per-checkout state — regenerable IDE
- * types (`lecodes update`) + `manifest.json`, this machine's push cursor (baseHeadId + per-file shas).
- * Committing it makes collaborators fight over the cursor and ship stale types, so every scaffold
- * path (init / clone / link) makes sure it's ignored. Render outputs mirror DEFAULT_IGNORE_FILE. */
-export const DEFAULT_GITIGNORE = `# LeCodes per-checkout state: generated IDE types + this machine's sync cursor
-# (.lecodes/manifest.json). Regenerate with \`lecodes update\` / re-attach with \`lecodes link\`.
-.lecodes/
-
-# Render / preview outputs and test failure frames
-screenshot.png
-shots/
-tests/.artifacts/
-tests/.shots/
-
-node_modules/
-
-dist/
-`
-
-/** Create `.gitignore` if missing; if it exists but doesn't ignore `.lecodes/`, append that rule.
- * Returns what happened so callers can log it ("created" | "updated" | null). */
-export const ensureGitignore = (root: string): "created" | "updated" | null => {
-  const file = join(root, ".gitignore")
-  if (!existsSync(file)) { writeFileSync(file, DEFAULT_GITIGNORE); return "created" }
-  const text = readFileSync(file, "utf8")
-  const covered = text.split(/\r?\n/).some(l => /^\/?\.lecodes\/?\s*$/.test(l.trim()))
-  if (covered) return null
-  const sep = text.length === 0 || text.endsWith("\n") ? "" : "\n"
-  writeFileSync(file, `${text}${sep}\n# LeCodes per-checkout state (generated types + sync cursor) — not source\n.lecodes/\n`)
-  return "updated"
-}
+import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+
+/*
+ * `.lecodesignore` support — keeps scratch files (temp probes, render screenshots, logs) out of
+ * `status` / `push` so they never land in a checkpoint. Syntax is a practical subset of .gitignore:
+ *   - blank lines and `# comments` are skipped
+ *   - `!pattern` re-includes something a previous pattern ignored
+ *   - a trailing `/` matches directories only
+ *   - a leading `/` (or any embedded `/`) anchors the pattern to the project root
+ *   - `*` matches within a path segment, `**` across segments, `?` a single char
+ *   - a slash-free pattern (e.g. `_*`, `*.png`) matches a basename at any depth
+ *
+ * IMPORTANT: ignores apply to UNTRACKED files only. A file already in the project (recorded in the
+ * manifest) is always tracked, even if it matches a pattern — so ignoring `*.png` can never make an
+ * existing image asset silently disappear from the project. Pruning happens in `scanLocal`.
+ */
+
+export type IgnoreMatcher = (key: string, isDir: boolean) => boolean
+
+type Rule = { re: RegExp, negate: boolean, dirOnly: boolean }
+
+// Always applied, even with no .lecodesignore — only patterns that are never real project assets, so
+// they're safe as invisible defaults. Everything asset-shaped (*.png, *.json, …) is opt-in via the
+// file written at clone time (see DEFAULT_IGNORE_FILE). `.artifacts/` is `lecodes test`'s
+// failure-frame dump dir (tests/.artifacts/) — regenerated scratch, never a project asset.
+// `dist/` is `lecodes app build desktop`'s default output (<root>/dist/<slug>, appDesktop.ts) —
+// same class, but it must be ignored for a second, load-bearing reason: that folder holds a COPY of
+// the host's runtime assets (lit.filamat, uberarchive.bin, …). Collected as project assets they get
+// staged next to the bundle, and onFetchLocal searches the bundle's dir BEFORE the host's assets dir
+// (main.cpp) — so the copy shadows the host's own. Harmless while every host was OpenGL and the
+// bytes matched; fatal once a build output can come from the Vulkan host, where the shadowing
+// lit.filamat is SPIR-V and Filament aborts with "not built for any of the OpenGL backend's
+// supported shader languages".
+// `.env` / `.env.*`: the project's LECODES_* config (projectEnv.ts) — it holds tokens and keystore
+// passwords, so it never leaves the machine whatever .lecodesignore says.
+// `.lightmap/` = a bake's float debug layers (`lecodes lightmap bake --debug-dir`): gigabytes the compile scan must never read
+const BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store", ".artifacts/", "dist/", ".env", ".env.*", ".lightmap/"]
+
+/** Template `.lecodesignore` written on clone — the explicit, editable "what we don't push" list. */
+export const DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
+# Only untracked files are affected — assets already in the project stay tracked
+# even if they match a pattern. Built-in defaults (node_modules, _*, *.log, .artifacts)
+# always apply.
+
+# Render / preview outputs (the default \`lecodes render --png\` target)
+screenshot.png
+shots/
+
+# Design-board comments live on the platform; design/comments/ is the local mirror of the
+# open ones (\`lecodes design comments pull\`) — read by Claude, but pushing it back as
+# project files would only duplicate the database.
+design/comments/
+
+# Image & other binary assets ARE pushed by default — they're real project resources.
+# Uncomment a pattern below only if you want to keep some untracked ones out of pushes.
+# *.png
+
+# Local notes & dumps (uncomment to ignore)
+# *.json
+# notes.md
+`
+
+/** Translate a glob (one path segment's worth of `*`/`?`/`**`) into a regex fragment. */
+const translate = (glob: string): string => {
+  let re = ""
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i]
+    if (ch === "*") {
+      if (glob[i + 1] === "*") { re += ".*"; i++; if (glob[i + 1] === "/") i++ } // `**/` spans dirs
+      else re += "[^/]*"
+    } else if (ch === "?") re += "[^/]"
+    else if (ch === "/") re += "/"
+    else if ("\\^$.|+()[]{}".includes(ch)) re += "\\" + ch
+    else re += ch
+  }
+  return re
+}
+
+const compile = (raw: string): Rule | null => {
+  let p = raw.trim()
+  if (!p || p.startsWith("#")) return null
+  let negate = false
+  if (p.startsWith("!")) { negate = true; p = p.slice(1) }
+  let dirOnly = false
+  if (p.endsWith("/")) { dirOnly = true; p = p.slice(0, -1) }
+  const anchored = p.startsWith("/") || p.includes("/")
+  if (p.startsWith("/")) p = p.slice(1)
+  if (!p) return null
+  const body = translate(p)
+  // `(/.*)?$` lets a directory pattern also match files nested under it, matching gitignore behavior
+  // even without relying on directory pruning.
+  const re = anchored ? new RegExp("^/" + body + "(/.*)?$") : new RegExp("(^|/)" + body + "(/.*)?$")
+  return { re, negate, dirOnly }
+}
+
+const buildMatcher = (rules: Rule[]): IgnoreMatcher => (key, isDir) => {
+  let ignored = false
+  for (const r of rules) {
+    if (r.dirOnly && !isDir) continue // a `foo/` rule only matches dirs directly (files via prune)
+    if (r.re.test(key)) ignored = !r.negate
+  }
+  return ignored
+}
+
+/** Compile a standalone glob list (same syntax as .lecodesignore lines, including `!` re-includes)
+ *  into a file-path matcher — used for app.json's `resources.remote` patterns. */
+export const buildGlobMatcher = (patterns: string[]): ((path: string) => boolean) => {
+  // Matching is over FILE paths — normalize `videos/` (dir-only, would match nothing here) to
+  // `videos`, whose `(/.*)?$` tail matches everything under the directory.
+  const rules = patterns.map((p) => compile(p.trim().replace(/\/+$/, ""))).filter((r): r is Rule => r !== null)
+  const match = buildMatcher(rules)
+  // Anchored rules compile to `^/…` — they expect the canonical leading-slash key form.
+  return (path) => match(path.startsWith("/") ? path : "/" + path, false)
+}
+
+/** Read `<root>/.lecodesignore` (if any) and combine with the built-in defaults into a matcher. */
+export const loadIgnore = (root: string): IgnoreMatcher => {
+  const lines = [...BUILTIN_PATTERNS]
+  const file = join(root, ".lecodesignore")
+  if (existsSync(file)) {
+    try { lines.push(...readFileSync(file, "utf8").split(/\r?\n/)) } catch { /* unreadable → defaults only */ }
+  }
+  const rules = lines.map(compile).filter((r): r is Rule => r !== null)
+  return buildMatcher(rules)
+}
+
+/** Write the template `.lecodesignore` if the project doesn't have one yet (used on clone). */
+export const writeDefaultIgnore = (root: string) => {
+  const file = join(root, ".lecodesignore")
+  if (!existsSync(file)) writeFileSync(file, DEFAULT_IGNORE_FILE)
+}
+
+/* `.gitignore` for the project's OWN git repo. `.lecodes/` is per-checkout state — regenerable IDE
+ * types (`lecodes update`) + `manifest.json`, this machine's push cursor (baseHeadId + per-file shas).
+ * Committing it makes collaborators fight over the cursor and ship stale types, so every scaffold
+ * path (init / clone / link) makes sure it's ignored. Render outputs mirror DEFAULT_IGNORE_FILE. */
+export const DEFAULT_GITIGNORE = `# LeCodes per-checkout state: generated IDE types + this machine's sync cursor
+# (.lecodes/manifest.json). Regenerate with \`lecodes update\` / re-attach with \`lecodes link\`.
+.lecodes/
+
+# Render / preview outputs and test failure frames
+screenshot.png
+shots/
+tests/.artifacts/
+tests/.shots/
+
+node_modules/
+
+dist/
+`
+
+/** Create `.gitignore` if missing; if it exists but doesn't ignore `.lecodes/`, append that rule.
+ * Returns what happened so callers can log it ("created" | "updated" | null). */
+export const ensureGitignore = (root: string): "created" | "updated" | null => {
+  const file = join(root, ".gitignore")
+  if (!existsSync(file)) { writeFileSync(file, DEFAULT_GITIGNORE); return "created" }
+  const text = readFileSync(file, "utf8")
+  const covered = text.split(/\r?\n/).some(l => /^\/?\.lecodes\/?\s*$/.test(l.trim()))
+  if (covered) return null
+  const sep = text.length === 0 || text.endsWith("\n") ? "" : "\n"
+  writeFileSync(file, `${text}${sep}\n# LeCodes per-checkout state (generated types + sync cursor) — not source\n.lecodes/\n`)
+  return "updated"
+}

package/runtime/materials/lightmap-baked-lite.mat

@@ -1,180 +0,0 @@
-// lightmap-baked-lite: the lightmap material's CHEAPEST tier (SDK `Material.lightmapShading =
-// "baked-lite"`). lightmap-baked (the unlit twin with hand-written lighting) with the per-pixel texture
-// reads cut on the LEVEL: a static (the atlas path) reads base colour, emissive and the two atlas pages
-// only — no normal map (the geometric normal shades), no metallic/roughness map, no occlusion map (the
-// atlas' baked AO stays). A dynamic object (the volume path: weapons, hands, bots — few pixels) keeps
-// every read of lightmap-baked, so the gun in front of the camera looks the same on every tier.
-// Emissive MUST stay: the lamps and signs glow through it.
-//
-// Trap (2026-09-07): with the metallic/roughness map gone, `metallicFactor` alone is WRONG — every
-// pack material here declares metallicFactor 1 and lets the map carry the metalness, so the factor
-// made the whole level fully metallic (diffuse 0 → a dark scene, a dark rifle). Without the map a
-// static is a dielectric (metallic 0, roughness = the factor floored at 0.6).
-// Measured on fps-demo's shooting range at 1920x1080 (integrated GPU, LOW preset): a 3-read probe of
-// this shape ran +20 % over lightmap-baked (62–69 vs 48–59 fps); at 1280x720 only +3–5 % — texture
-// bandwidth is the remaining per-pixel bill at the target resolution.
-// Keep the parameter list IDENTICAL to lightmap.mat (see lightmap-baked.mat): every parameter is set
-// by creator-gl whether the shader reads it or not, and an undeclared uniform is a panic.
-
-material {
-    name : lightmap_baked_lite,
-    shadingModel : unlit,
-    doubleSided : true,
-    // opaque or masked: matc -TBLENDING (materials.json `variants`) — the masked twin is what the
-    // lightmap provider hands a glTF MASK material (foliage cards), same shader otherwise
-    blending : ${BLENDING},
-    flipUV : false,
-    requires : [ uv0, uv1, tangents ],
-    parameters : [
-        { type : float4,    name : baseColorFactor },
-        { type : sampler2d, name : baseColorMap },
-        { type : float,     name : metallicFactor },
-        { type : float,     name : roughnessFactor },
-        { type : float3,    name : emissiveFactor },
-        { type : float,     name : normalScale },
-        { type : float,     name : aoStrength },
-        { type : sampler2d, name : normalMap },
-        { type : float,     name : hasNormalMap },
-        { type : sampler2d, name : metallicRoughnessMap },
-        { type : sampler2d, name : occlusionMap },
-        { type : sampler2d, name : emissiveMap },
-        { type : sampler2d, name : lightmap },
-        { type : sampler2d, name : lightmapLight },
-        { type : float,     name : lightScale },
-        { type : float,     name : lightGamma },
-        { type : float4,    name : lightmapST },
-        { type : float,     name : ambientScale },
-        { type : float,     name : sunStrength },
-        { type : float,     name : bakedAo },
-        { type : sampler3d, name : probeVolume },
-        { type : sampler3d, name : probeLight },
-        { type : float4,    name : probeMin },
-        { type : float4,    name : probeInvSize }
-    ]
-}
-
-fragment {
-    // filament's SH irradiance (Lambert baked into the coefficients, like Irradiance_SphericalHarmonics)
-    vec3 shIrradiance(const vec3 n) {
-        return max(
-            frameUniforms.iblSH[0].xyz
-            + frameUniforms.iblSH[1].xyz * n.y + frameUniforms.iblSH[2].xyz * n.z + frameUniforms.iblSH[3].xyz * n.x
-            + frameUniforms.iblSH[4].xyz * (n.y * n.x) + frameUniforms.iblSH[5].xyz * (n.y * n.z)
-            + frameUniforms.iblSH[6].xyz * (3.0 * n.z * n.z - 1.0) + frameUniforms.iblSH[7].xyz * (n.z * n.x)
-            + frameUniforms.iblSH[8].xyz * (n.x * n.x - n.y * n.y), 0.0);
-    }
-
-    // Karis' analytic DFG (UE4 mobile): the split-sum's E term without the LUT
-    vec3 envBrdfApprox(const vec3 f0, float roughness, float NoV) {
-        vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022);
-        vec4 c1 = vec4(1.0, 0.0425, 1.04, -0.04);
-        vec4 r = roughness * c0 + c1;
-        float a004 = min(r.x * r.x, exp2(-9.28 * NoV)) * r.x + r.y;
-        vec2 ab = vec2(-1.04, 1.04) * a004 + r.zw;
-        return f0 * ab.x + ab.y;
-    }
-
-    void material(inout MaterialInputs material) {
-        prepareMaterial(material);
-        vec4 base = texture(materialParams_baseColorMap, getUV0()) * materialParams.baseColorFactor;
-        // a dynamic object (volume-lit) keeps lightmap-baked's reads; a static reads nothing but base,
-        // emissive and the atlas — and without its metal/rough map it is a dielectric (see the header)
-        bool dyn = materialParams.probeInvSize.w > 0.5;
-        float metallic = 0.0;
-        float roughness = max(materialParams.roughnessFactor, 0.6);
-        float occ = 1.0;
-        if (dyn) {
-            vec2 mr = texture(materialParams_metallicRoughnessMap, getUV0()).bg;
-            metallic = materialParams.metallicFactor * mr.x;
-            roughness = materialParams.roughnessFactor * mr.y;
-            occ = 1.0 + materialParams.aoStrength * (texture(materialParams_occlusionMap, getUV0()).r - 1.0);
-        }
-        vec3 glow = texture(materialParams_emissiveMap, getUV0()).rgb * materialParams.emissiveFactor;
-        vec3 n = getWorldGeometricNormalVector();
-        vec3 ns = n;
-        if (dyn && materialParams.hasNormalMap > 0.5) {
-            vec3 tn = texture(materialParams_normalMap, getUV0()).xyz * 2.0 - 1.0;
-            tn.xy *= materialParams.normalScale;
-            // unlit has no vertex tangent frame (MATERIAL_NEEDS_TBN is lit-only): build one from the
-            // screen-space derivatives of position and uv0 (Schueler's cotangent frame)
-            highp vec3 p = getWorldPosition();
-            highp vec2 uv = getUV0();
-            highp vec3 dp1 = dFdx(p), dp2 = dFdy(p);
-            highp vec2 duv1 = dFdx(uv), duv2 = dFdy(uv);
-            highp vec3 dp2perp = cross(dp2, n), dp1perp = cross(n, dp1);
-            highp vec3 T = dp2perp * duv1.x + dp1perp * duv2.x;
-            highp vec3 B = dp2perp * duv1.y + dp1perp * duv2.y;
-            highp float invmax = inversesqrt(max(dot(T, T), dot(B, B)));
-            ns = normalize(mat3(T * invmax, B * invmax, n) * tn);
-        }
-        vec3 v = getWorldViewVector();
-        float NoV = max(dot(ns, v), 1e-4);
-        vec3 luma = vec3(0.2126, 0.7152, 0.0722);
-        float lg = materialParams.lightGamma > 0.0 ? materialParams.lightGamma : 1.0;
-
-        // the baked lamps: the volume for a dynamic object, the atlas for a static — as lightmap.mat
-        vec2 lm;
-        vec3 baked;
-        vec3 l;
-        if (materialParams.probeInvSize.w > 0.5) {
-            vec3 p = getUserWorldPosition() + n * materialParams.probeMin.w;
-            vec3 uvw = (p - materialParams.probeMin.xyz) * materialParams.probeInvSize.xyz;
-            lm = texture(materialParams_probeVolume, uvw).rg;
-            float nz = materialParams.probeInvSize.w;
-            float wz = clamp(uvw.z, 0.5 / nz, 1.0 - 0.5 / nz);
-            vec3 fx = vec3(uvw.xy, ((ns.x >= 0.0 ? 0.0 : 1.0) + wz) / 6.0);
-            vec3 fy = vec3(uvw.xy, ((ns.y >= 0.0 ? 2.0 : 3.0) + wz) / 6.0);
-            vec3 fz = vec3(uvw.xy, ((ns.z >= 0.0 ? 4.0 : 5.0) + wz) / 6.0);
-            vec3 ex = pow(texture(materialParams_probeLight, fx).rgb, vec3(lg));
-            vec3 ey = pow(texture(materialParams_probeLight, fy).rgb, vec3(lg));
-            vec3 ez = pow(texture(materialParams_probeLight, fz).rgb, vec3(lg));
-            vec3 w2 = ns * ns;
-            baked = (w2.x * ex + w2.y * ey + w2.z * ez) * materialParams.lightScale;
-            vec3 dirE = vec3(sign(ns.x) * dot(ex, luma), sign(ns.y) * dot(ey, luma), sign(ns.z) * dot(ez, luma));
-            l = dot(dirE, dirE) > 1e-12 ? normalize(dirE) : ns;
-        } else {
-            vec2 luv = getUV1() * materialParams.lightmapST.xy + materialParams.lightmapST.zw;
-            lm = texture(materialParams_lightmap, luv).rg;
-            baked = pow(texture(materialParams_lightmapLight, luv).rgb, vec3(lg)) * materialParams.lightScale;
-            l = ns;
-        }
-        lm.g = mix(1.0, lm.g, materialParams.bakedAo);
-        float ao = lm.g * occ;
-        float vis = mix(1.0, lm.r, materialParams.sunStrength);
-
-        vec3 diffuseColor = base.rgb * (1.0 - metallic);
-        vec3 f0 = mix(vec3(0.04), base.rgb, metallic);
-        vec3 E = envBrdfApprox(f0, roughness, NoV);
-
-        vec3 ambD = diffuseColor * shIrradiance(ns) * (1.0 - E) * ao * frameUniforms.iblLuminance;
-        vec3 ambS = E * shIrradiance(reflect(-v, ns)) * ao * frameUniforms.iblLuminance;
-        vec3 color = (ambD + ambS) * materialParams.ambientScale;
-
-        // the sun (a level with one): Lambert × the atlas' visibility mask; pre-exposed like filament's own
-        float sunW = frameUniforms.lightColorIntensity.w;
-        if (sunW > 0.0) {
-            float NoL = max(dot(ns, frameUniforms.lightDirection), 0.0);
-            color += diffuseColor * frameUniforms.lightColorIntensity.rgb * (sunW * NoL * vis / PI);
-        }
-
-        // the baked lamps: diffuse + the cheap specular lobe lightmap.mat also uses (physical units × exposure)
-        {
-            vec3 h = normalize(v + l);
-            float NoL = max(dot(ns, l), 0.0);
-            float NoH = max(dot(ns, h), 0.0);
-            float LoH = max(dot(l, h), 0.0);
-            float pr = max(roughness, 0.5);
-            float a2 = pr * pr;
-            a2 *= a2;
-            float dd = NoH * NoH * (a2 - 1.0) + 1.0;
-            float D = a2 / (PI * dd * dd);
-            float V = 0.5 / max(NoL * sqrt(NoV * NoV * (1.0 - a2) + a2) + NoV * sqrt(NoL * NoL * (1.0 - a2) + a2), 1e-4);
-            vec3 F = f0 + (1.0 - f0) * pow(1.0 - LoH, 5.0);
-            color += (diffuseColor / PI + D * V * F) * baked * getExposure();
-        }
-
-        // the texture's alpha rides along: the masked twin (-TBLENDING=masked) cuts foliage cards on it,
-        // the opaque one ignores it (an unlit opaque material writes no alpha)
-        material.baseColor = vec4(color + glow, base.a);
-    }
-}