lecodes-cli 2.4.10 → 2.5.0

package/package.json

@@ -1,23 +1,23 @@
 {
   "name": "lecodes-cli",
-  "version": "2.4.10",
+  "version": "2.5.0",
   "dependencies": {
     "@letary/chisel": "^0.15.0",
     "jimp": "^1.6.1",
-    "lecodes-sdk": "2.4.10",
+    "lecodes-sdk": "2.5.0",
     "selfsigned": "^2.4.1"
   },
   "devDependencies": {
     "lecodes-design": "https://storage.yandexcloud.net/le-codes/releases/packages/lecodes-design/lecodes-design-0.11.0.tgz",
-    "lecodes-headless": "2.4.10",
+    "lecodes-headless": "2.5.0",
     "qrcode-terminal": "^0.12.0",
     "lecodes-3d-editor": "https://storage.yandexcloud.net/le-codes/releases/packages/lecodes-3d-editor/lecodes-3d-editor-0.9.0.tgz",
-    "lecodes-assets": "2.4.10",
+    "lecodes-assets": "2.5.0",
     "lecodes-creator-nav": "0.19.0",
-    "lecodes-gl-lite": "2.4.10",
-    "lecodes-web-frame": "2.4.10",
-    "lecodes-web-player": "2.4.10",
-    "lecodes-web-shared": "2.4.10",
+    "lecodes-gl-lite": "2.5.0",
+    "lecodes-web-frame": "2.5.0",
+    "lecodes-web-player": "2.5.0",
+    "lecodes-web-shared": "2.5.0",
     "lecodes-web-lite": "2.0.7",
     "heic-decode": "^2.1.0",
     "marcidb-embedded": "^0.15.0",
@@ -25,9 +25,9 @@
   },
   "peerDependencies": {
     "lecodes-design": "^0.11.0",
-    "lecodes-headless": "^2.4.10",
+    "lecodes-headless": "^2.5.0",
     "lecodes-3d-editor": "^0.9.0",
-    "lecodes-assets": "^2.4.10",
+    "lecodes-assets": "^2.5.0",
     "heic-decode": "^2.1.0",
     "marcidb-embedded": "^0.15.0",
     "sharp": "^0.35.2",

package/runtime/materials/decal-relief.mat

@@ -1,6 +1,6 @@
 // Relief decal material (SDK: Material.decal({ normalMap }) — a DecalSet with a `normalMap`). The
-// projection is decal.mat's: the box, the depth-aware bilinear structure read, the unit-space
-// test, the atlas rect, the life fade. What differs is WHAT it paints: not a colour but a change
+// projection is decal.mat's: the box, the scene-depth read (the colour pass's own depth, fork
+// patch 0017), the unit-space test, the atlas rect, the life fade. What differs is WHAT it paints: not a colour but a change
 // of the surface's own lighting. A forward renderer has already shaded the wall when the decal is
 // drawn, so the normal map cannot bend the wall's normal; instead this shader shades the surface
 // point twice — with the normal reconstructed from the depth buffer, and with that normal bent by
@@ -86,32 +86,11 @@ fragment {
         vec3 value = vec3(1.0);
         float alpha = 0.0;
 #if !defined(VARIANT_DEPTH)
-        highp vec3 wp = getWorldPosition();
-        highp vec4 clip = getClipFromWorldMatrix() * vec4(wp, 1.0);
-        highp vec2 suv = clip.xy * (0.5 / clip.w) + 0.5;
-        highp mat4 p = getViewFromClipMatrix();
-        // depth-aware bilinear structure read — see decal.mat
+        // the pixel centre's ray and the scene depth under this very pixel — see decal.mat
         highp vec2 ssz = vec2(textureSize(sampler0_structure, 0));
-        highp vec2 ts = 1.0 / ssz;
-        highp vec2 pix = suv * ssz - 0.5;
-        highp vec2 base = (floor(pix) + 0.5) * ts;
-        highp vec2 fr = fract(pix);
-        highp float d00 = textureLod(sampler0_structure, uvToRenderTargetUV(base), 0.0).r;
-        highp float d10 = textureLod(sampler0_structure, uvToRenderTargetUV(base + vec2(ts.x, 0.0)), 0.0).r;
-        highp float d01 = textureLod(sampler0_structure, uvToRenderTargetUV(base + vec2(0.0, ts.y)), 0.0).r;
-        highp float d11 = textureLod(sampler0_structure, uvToRenderTargetUV(base + ts), 0.0).r;
-        highp float z00 = (d00 * p[2].z + p[3].z) / max(d00 * p[2].w + p[3].w, 1.0 / 16777216.0);
-        highp float z10 = (d10 * p[2].z + p[3].z) / max(d10 * p[2].w + p[3].w, 1.0 / 16777216.0);
-        highp float z01 = (d01 * p[2].z + p[3].z) / max(d01 * p[2].w + p[3].w, 1.0 / 16777216.0);
-        highp float z11 = (d11 * p[2].z + p[3].z) / max(d11 * p[2].w + p[3].w, 1.0 / 16777216.0);
-        highp float zRef = fr.x < 0.5 ? (fr.y < 0.5 ? z00 : z01) : (fr.y < 0.5 ? z10 : z11);
-        highp float tol = max(0.05 * abs(zRef), 0.03);
-        highp float w00 = (1.0 - fr.x) * (1.0 - fr.y) * step(abs(z00 - zRef), tol);
-        highp float w10 = fr.x * (1.0 - fr.y) * step(abs(z10 - zRef), tol);
-        highp float w01 = (1.0 - fr.x) * fr.y * step(abs(z01 - zRef), tol);
-        highp float w11 = fr.x * fr.y * step(abs(z11 - zRef), tol);
-        highp float wsum = max(w00 + w10 + w01 + w11, 1e-6);
-        highp float sceneDepth = (d00 * w00 + d10 * w10 + d01 * w01 + d11 * w11) / wsum;
+        highp vec2 suv = getFragCoord(ssz) / ssz;
+        highp mat4 p = getViewFromClipMatrix();
+        highp float sceneDepth = texelFetch(sampler0_structure, ivec2(gl_FragCoord.xy), 0).r;
         highp vec4 vc = p * vec4(suv * 2.0 - 1.0, sceneDepth, 1.0);
         highp vec3 sv = vc.xyz / vc.w;
         highp vec3 sw = (getWorldFromViewMatrix() * vec4(sv, 1.0)).xyz;
@@ -131,24 +110,20 @@ fragment {
         float4 tint = getColor();
         alpha = tint.a;
 
-        // The surface normal from texel centres of the structure buffer (see decal.mat) — needed
+        // The surface normal from the depth texels around this pixel (see decal.mat) — needed
         // here always: it is the normal the relief bends.
-        highp vec2 sel = vec2(fr.x < 0.5 ? 0.0 : ts.x, fr.y < 0.5 ? 0.0 : ts.y);
-        highp vec2 cuv = base + sel;
-        highp float dc = fr.x < 0.5 ? (fr.y < 0.5 ? d00 : d01) : (fr.y < 0.5 ? d10 : d11);
-        highp float dl = textureLod(sampler0_structure, uvToRenderTargetUV(cuv - vec2(ts.x, 0.0)), 0.0).r;
-        highp float dr = textureLod(sampler0_structure, uvToRenderTargetUV(cuv + vec2(ts.x, 0.0)), 0.0).r;
-        highp float dd = textureLod(sampler0_structure, uvToRenderTargetUV(cuv - vec2(0.0, ts.y)), 0.0).r;
-        highp float du = textureLod(sampler0_structure, uvToRenderTargetUV(cuv + vec2(0.0, ts.y)), 0.0).r;
-        highp vec2 ndc = cuv * 2.0 - 1.0;
-        highp vec4 vcc = p * vec4(ndc, dc, 1.0);
+        highp vec2 ts = 1.0 / vec2(textureSize(sampler0_structure, 0));
+        highp float dl = textureLod(sampler0_structure, uvToRenderTargetUV(suv - vec2(ts.x, 0.0)), 0.0).r;
+        highp float dr = textureLod(sampler0_structure, uvToRenderTargetUV(suv + vec2(ts.x, 0.0)), 0.0).r;
+        highp float dd = textureLod(sampler0_structure, uvToRenderTargetUV(suv - vec2(0.0, ts.y)), 0.0).r;
+        highp float du = textureLod(sampler0_structure, uvToRenderTargetUV(suv + vec2(0.0, ts.y)), 0.0).r;
+        highp vec2 ndc = suv * 2.0 - 1.0;
         highp vec4 vl = p * vec4(ndc - vec2(2.0 * ts.x, 0.0), dl, 1.0);
         highp vec4 vr = p * vec4(ndc + vec2(2.0 * ts.x, 0.0), dr, 1.0);
         highp vec4 vd = p * vec4(ndc - vec2(0.0, 2.0 * ts.y), dd, 1.0);
         highp vec4 vu = p * vec4(ndc + vec2(0.0, 2.0 * ts.y), du, 1.0);
-        highp vec3 sc = vcc.xyz / vcc.w;
-        highp vec3 ex = abs(dr - dc) < abs(dl - dc) ? vr.xyz / vr.w - sc : sc - vl.xyz / vl.w;
-        highp vec3 ey = abs(du - dc) < abs(dd - dc) ? vu.xyz / vu.w - sc : sc - vd.xyz / vd.w;
+        highp vec3 ex = abs(dr - sceneDepth) < abs(dl - sceneDepth) ? vr.xyz / vr.w - sv : sv - vl.xyz / vl.w;
+        highp vec3 ey = abs(du - sceneDepth) < abs(dd - sceneDepth) ? vu.xyz / vu.w - sv : sv - vd.xyz / vd.w;
         highp vec3 nv = cross(ex, ey);
         highp float nl = length(nv);
         highp vec3 axis = normalize(variable_inv2.xyz);
@@ -162,12 +137,12 @@ fragment {
         if (edge > 0.0) alpha *= saturate((0.5 - abs(local.z)) / (0.5 * edge));
 
         highp vec2 uv = vec2(local.x + 0.5, 0.5 - local.y);
-        // The atlas rect, packed two 11-bit values to a float (decals.h) to make room for the caps.
-        highp float p0 = floor(variable_rect.x + 0.5), p1 = floor(variable_rect.y + 0.5);
-        highp float u0i = floor(p0 / 2048.0), u1i = floor(p1 / 2048.0);
-        highp vec2 rect0 = vec2(u0i, p0 - u0i * 2048.0) / 2047.0;
-        highp vec2 rect1 = vec2(u1i, p1 - u1i * 2048.0) / 2047.0;
-        highp vec2 tuv = mix(rect0, rect1, uv);
+        // The atlas cell as small integers — see decal.mat
+        highp float pc = floor(variable_rect.x + 0.5), ps = floor(variable_rect.y + 0.5);
+        highp float col = floor(pc / 256.0), row = pc - col * 256.0;
+        highp float cols = floor(ps / 256.0), rows = ps - cols * 256.0;
+        highp vec2 cell = 1.0 / vec2(cols, rows);
+        highp vec2 tuv = (vec2(col, row) + uv) * cell;
 
         // The bent normal: the map's xy along the decal's right / up, z along the surface normal.
         vec3 T = normalize(variable_inv0.xyz);

package/runtime/materials/decal.mat

@@ -1,19 +1,21 @@
 // Projected decal material (SDK: Material.decal({ map }); native DecalSet in creator-gl
 // src/decals.cpp). One DecalSet is ONE renderable of unit boxes. The fragment stage does not shade
-// the box: it reads the scene depth behind the fragment (Filament's structure buffer, bound to the
-// colour pass by creator-gl patch 0017 while a set has live decals), reconstructs the scene point
+// the box: it reads the scene depth behind the fragment (the colour pass's own depth after the
+// opaque objects — Filament fork patch 0017 splits the pass and binds it to the blended half as
+// sampler0_structure while creator-gl's scene_depth.cpp asks for it), reconstructs the scene point
 // on the fragment's eye ray, maps it into the decal's unit space with the inverse frame the vertex
 // carries, discards outside the box and samples the atlas cell there. So a decal lands on whatever
 // opaque surface sits inside its box — floor, wall, corner, stairs, a curved rock — with no
 // geometry access at all. It never lands on blended things (particles, glass, other decals): they
-// are not in the structure pass.
+// draw after the capture.
 //
 // Per-vertex inputs (DECAL_VERTEX_FLOATS in decals.h, one interleaved buffer, 8 corners per decal):
 //   POSITION      — the box corner in the SET's space (the renderable's model space)
 //   CUSTOM0..2    — rows of the 3x4 inverse frame: unit box ← set space
-//   CUSTOM3       — pack(u0,v0), pack(u1,v1) (the atlas rect, two 11-bit 0..1 values per float;
-//                   v0 = the cell's top, image top = +Y of the box), capStart, capEnd (tilt of the
-//                   bottom / top edge in unit space — a trail segment's mitred joints, 0 = square)
+//   CUSTOM3       — col·256 + row, cols·256 + rows (the atlas cell on its sheet grid, as small
+//                   integers — see decals.h for why not packed uv; row 0 = the top, image top =
+//                   +Y of the box), capStart, capEnd (tilt of the bottom / top edge in unit
+//                   space — a trail segment's mitred joints, 0 = square)
 //   COLOR         — tint rgba (a = opacity, already × the gradient end at each corner: −Y corners
 //                   carry alphaStart, +Y ones alphaEnd, so a trail darkens along its length)
 //   CUSTOM4       — born, life, fadeIn, fadeOut (seconds on the `time` clock; life 0 = forever)
@@ -82,40 +84,21 @@ fragment {
         float alpha = 0.0;
         float3 rgb = float3(0.0);
 #if !defined(VARIANT_DEPTH)
-        // The scene point behind this fragment: the structure buffer's depth on the same eye ray.
+        // The scene point behind this fragment: the scene depth on the eye ray through the
+        // PIXEL CENTRE. The sampler holds the colour pass's own depth (full resolution, one texel
+        // per pixel — fork patch 0017), fetched at gl_FragCoord: the texel the opaque surface
+        // wrote under this very pixel, no reconstruction filter. The ray comes from the same
+        // pixel centre (getFragCoord = gl_FragCoord in the GL convention on every backend) — NOT
+        // from the interpolated world position: under MSAA, GL may interpolate a varying anywhere
+        // inside a partly covered pixel (NVIDIA: not at the centre), and a ray through that spot
+        // with the centre's depth lands off the surface — a comb of dropped pixels along the
+        // box's silhouette at a grazing view; Vulkan, which interpolates at the centre, was clean.
         // Depth goes through Filament's SSR linearizeDepth formula (reversed-Z, far at infinity);
         // clip z is the stored depth itself, so viewFromClip * (ndc.xy, depth, 1) is a view point.
-        highp vec3 wp = getWorldPosition();
-        highp vec4 clip = getClipFromWorldMatrix() * vec4(wp, 1.0);
-        highp vec2 suv = clip.xy * (0.5 / clip.w) + 0.5;
-        highp mat4 p = getViewFromClipMatrix();
-        // Depth-aware BILINEAR read of the structure buffer. Filament binds it NEAREST and at half
-        // resolution, so a plain read quantises the projection to 2x2-pixel blocks (stair-stepped
-        // edges, blocky uv at oblique views). Hardware depth is affine in screen space on a plane,
-        // so interpolating the RAW depth between the four texel centres is exact there. Across a
-        // silhouette a mix would float in the air: taps whose linear depth strays from the nearest
-        // texel by more than a few percent are dropped (weights renormalised).
         highp vec2 ssz = vec2(textureSize(sampler0_structure, 0));
-        highp vec2 ts = 1.0 / ssz;
-        highp vec2 pix = suv * ssz - 0.5;
-        highp vec2 base = (floor(pix) + 0.5) * ts;
-        highp vec2 fr = fract(pix);
-        highp float d00 = textureLod(sampler0_structure, uvToRenderTargetUV(base), 0.0).r;
-        highp float d10 = textureLod(sampler0_structure, uvToRenderTargetUV(base + vec2(ts.x, 0.0)), 0.0).r;
-        highp float d01 = textureLod(sampler0_structure, uvToRenderTargetUV(base + vec2(0.0, ts.y)), 0.0).r;
-        highp float d11 = textureLod(sampler0_structure, uvToRenderTargetUV(base + ts), 0.0).r;
-        highp float z00 = (d00 * p[2].z + p[3].z) / max(d00 * p[2].w + p[3].w, 1.0 / 16777216.0);
-        highp float z10 = (d10 * p[2].z + p[3].z) / max(d10 * p[2].w + p[3].w, 1.0 / 16777216.0);
-        highp float z01 = (d01 * p[2].z + p[3].z) / max(d01 * p[2].w + p[3].w, 1.0 / 16777216.0);
-        highp float z11 = (d11 * p[2].z + p[3].z) / max(d11 * p[2].w + p[3].w, 1.0 / 16777216.0);
-        highp float zRef = fr.x < 0.5 ? (fr.y < 0.5 ? z00 : z01) : (fr.y < 0.5 ? z10 : z11);
-        highp float tol = max(0.05 * abs(zRef), 0.03);
-        highp float w00 = (1.0 - fr.x) * (1.0 - fr.y) * step(abs(z00 - zRef), tol);
-        highp float w10 = fr.x * (1.0 - fr.y) * step(abs(z10 - zRef), tol);
-        highp float w01 = (1.0 - fr.x) * fr.y * step(abs(z01 - zRef), tol);
-        highp float w11 = fr.x * fr.y * step(abs(z11 - zRef), tol);
-        highp float wsum = max(w00 + w10 + w01 + w11, 1e-6);
-        highp float sceneDepth = (d00 * w00 + d10 * w10 + d01 * w01 + d11 * w11) / wsum;
+        highp vec2 suv = getFragCoord(ssz) / ssz;
+        highp mat4 p = getViewFromClipMatrix();
+        highp float sceneDepth = texelFetch(sampler0_structure, ivec2(gl_FragCoord.xy), 0).r;
         highp vec4 vc = p * vec4(suv * 2.0 - 1.0, sceneDepth, 1.0);
         highp vec3 sv = vc.xyz / vc.w;
         highp vec3 sw = (getWorldFromViewMatrix() * vec4(sv, 1.0)).xyz;
@@ -136,29 +119,22 @@ fragment {
         alpha = tint.a;
 
         // Surface facing for the angle fade (a floor decal reaching a wall). The normal comes from
-        // the structure buffer's own texels — NOT screen derivatives: the buffer is half-res, so a
-        // 2x2 quad often reads one texel and dFdx/dFdy then describe the view plane, not the
-        // surface. Every point here is a TEXEL CENTRE (the nearest one and its four neighbours):
-        // mixing the bilinear centre with nearest neighbours makes the differences wobble at texel
-        // frequency, which reads as hatching on a wall. Per axis the neighbour closer in depth wins
-        // (a silhouette is crossed on one side only).
+        // the depth texels around this pixel, not screen derivatives: at a silhouette a derivative
+        // straddles two surfaces, while here per axis the neighbour closer in depth wins (a
+        // silhouette is crossed on one side only). Every point is a texel centre = a pixel centre.
         if (materialParams.angleFade > 0.0) {
-            highp vec2 sel = vec2(fr.x < 0.5 ? 0.0 : ts.x, fr.y < 0.5 ? 0.0 : ts.y);
-            highp vec2 cuv = base + sel;                                   // nearest texel centre
-            highp float dc = fr.x < 0.5 ? (fr.y < 0.5 ? d00 : d01) : (fr.y < 0.5 ? d10 : d11);
-            highp float dl = textureLod(sampler0_structure, uvToRenderTargetUV(cuv - vec2(ts.x, 0.0)), 0.0).r;
-            highp float dr = textureLod(sampler0_structure, uvToRenderTargetUV(cuv + vec2(ts.x, 0.0)), 0.0).r;
-            highp float dd = textureLod(sampler0_structure, uvToRenderTargetUV(cuv - vec2(0.0, ts.y)), 0.0).r;
-            highp float du = textureLod(sampler0_structure, uvToRenderTargetUV(cuv + vec2(0.0, ts.y)), 0.0).r;
-            highp vec2 ndc = cuv * 2.0 - 1.0;
-            highp vec4 vcc = p * vec4(ndc, dc, 1.0);
+            highp vec2 ts = 1.0 / vec2(textureSize(sampler0_structure, 0));
+            highp float dl = textureLod(sampler0_structure, uvToRenderTargetUV(suv - vec2(ts.x, 0.0)), 0.0).r;
+            highp float dr = textureLod(sampler0_structure, uvToRenderTargetUV(suv + vec2(ts.x, 0.0)), 0.0).r;
+            highp float dd = textureLod(sampler0_structure, uvToRenderTargetUV(suv - vec2(0.0, ts.y)), 0.0).r;
+            highp float du = textureLod(sampler0_structure, uvToRenderTargetUV(suv + vec2(0.0, ts.y)), 0.0).r;
+            highp vec2 ndc = suv * 2.0 - 1.0;
             highp vec4 vl = p * vec4(ndc - vec2(2.0 * ts.x, 0.0), dl, 1.0);
             highp vec4 vr = p * vec4(ndc + vec2(2.0 * ts.x, 0.0), dr, 1.0);
             highp vec4 vd = p * vec4(ndc - vec2(0.0, 2.0 * ts.y), dd, 1.0);
             highp vec4 vu = p * vec4(ndc + vec2(0.0, 2.0 * ts.y), du, 1.0);
-            highp vec3 sc = vcc.xyz / vcc.w;
-            highp vec3 ex = abs(dr - dc) < abs(dl - dc) ? vr.xyz / vr.w - sc : sc - vl.xyz / vl.w;
-            highp vec3 ey = abs(du - dc) < abs(dd - dc) ? vu.xyz / vu.w - sc : sc - vd.xyz / vd.w;
+            highp vec3 ex = abs(dr - sceneDepth) < abs(dl - sceneDepth) ? vr.xyz / vr.w - sv : sv - vl.xyz / vl.w;
+            highp vec3 ey = abs(du - sceneDepth) < abs(dd - sceneDepth) ? vu.xyz / vu.w - sv : sv - vd.xyz / vd.w;
             highp vec3 nv = cross(ex, ey);
             highp float nl = length(nv);
             highp vec3 axisView = mat3(getViewFromWorldMatrix()) * normalize(variable_inv2.xyz);
@@ -170,12 +146,16 @@ fragment {
         if (edge > 0.0) alpha *= saturate((0.5 - abs(local.z)) / (0.5 * edge));
 
         highp vec2 uv = vec2(local.x + 0.5, 0.5 - local.y);
-        // The atlas rect, packed two 11-bit values to a float (decals.h) to make room for the caps.
-        highp float p0 = floor(variable_rect.x + 0.5), p1 = floor(variable_rect.y + 0.5);
-        highp float u0i = floor(p0 / 2048.0), u1i = floor(p1 / 2048.0);
-        highp vec2 rect0 = vec2(u0i, p0 - u0i * 2048.0) / 2047.0;
-        highp vec2 rect1 = vec2(u1i, p1 - u1i * 2048.0) / 2047.0;
-        highp vec2 tuv = mix(rect0, rect1, uv);
+        // The atlas cell: col·256 + row and cols·256 + rows (decals.h) — small integers, so the
+        // varying's interpolation rounding (relative, ~1e-7) cannot move them across a half
+        // (the packed 0..1 values this replaced sat near 2^22, where it did, and the cell's v
+        // range collapsed on scattered pixels — a comb along every decal of the last atlas row).
+        highp float pc = floor(variable_rect.x + 0.5), ps = floor(variable_rect.y + 0.5);
+        highp float col = floor(pc / 256.0), row = pc - col * 256.0;
+        highp float cols = floor(ps / 256.0), rows = ps - cols * 256.0;
+        highp vec2 cell = 1.0 / vec2(cols, rows);
+        highp vec2 rect0 = vec2(col, row) * cell;    // v0 = the cell's top (rows count downward)
+        highp vec2 tuv = rect0 + uv * cell;
         float4 tex = texture(materialParams_baseColorMap, tuv);
         alpha *= tex.a;
         if (alpha <= 0.002) discard;

package/runtime/materials/foliage-cards.mat

@@ -1,7 +1,13 @@
-// foliage-cards: the LEAN material of the vegetation tier's CARDS (leaves, needles, grass blades) — the same wind
-// (foliage-wind.vs) and the same parameters as foliage.mat, with the fragment cut to what a card seen past a few
-// metres needs (2026-10-18, the Forest testbed: foliage.mat's masked fragment was ~15 ms of a 49 ms frame on the
-// Radeon — a third of the forest). What moved or went:
+// foliage-cards: the LEAN material of a CROWN's cards (leaves, needles) — the same wind (foliage-wind.vs) and the same
+// parameters as foliage.mat, with the fragment cut to what a card seen past a few metres needs (2026-10-18, the Forest
+// testbed: foliage.mat's masked fragment was ~15 ms of a 49 ms frame on the Radeon — a third of the forest).
+// A CROWN IS A VOLUME IN THE AIR (2026-11-03, the split from grass.mat — the owner: a crown and a blade of grass are two
+// different things and had one shader): its ambient is the sky's SH on the crown's hull normal, darkened by the baked
+// per-vertex sky visibility (the crown's own depth), its sun the real-time light through the shadow map. It reads
+// NOTHING from the ground — the terrain's baked light is the GROUND's (its own cosine, the crown's shadow on it), and
+// read under a tree it was the tree's own shadow: a pine in full sun drew black, trunk and all (the owner's A/B,
+// CREATOR_FOLIAGE_GROUND=0 lit it right). Ground cover — the plant that IS the ground's surface — is grass.mat.
+// What moved or went, against foliage.mat:
 //   • the LIGHTING is PER VERTEX: the sky's SH on the crown's hull normal (the ambient) and the sun's wrapped
 //     Lambert + back-lit translucency (one scalar), interpolated over the card. Only the sun's SHADOW stays per
 //     pixel — Filament's lights loop hands it to surfaceShading() with every light (the material is `lit` with
@@ -11,11 +17,8 @@
 //   • no derivatives: the shading normal is the hull's (foliage.mat blends the card's own plane in), the mip
 //     coverage is estimated from the DISTANCE in the vertex shader (log2 of the distance over ~8 m), there is no
 //     edge fade
-//   • THE GROUND'S BAKED LIGHT is read per vertex too (groundLightV, 2026-10-18): the ambient under the vertex and the
-//     sun's baked share where the vertex's own sun ray meets the ground, so trees past the shadow map's reach stand in
-//     their neighbours' baked shadow; without a bound terrain the scene's sky lights every card
 // The engine treats it as foliage (it declares `benders`) and writes the same blocks; `Material.foliageCards`
-// in the SDK picks it for a model's MASK materials in place of foliage-masked.
+// in the SDK picks it for a crown's MASK materials in place of foliage-masked.
 
 material {
     name : foliage_cards,
@@ -27,7 +30,7 @@ material {
     alphaToCoverage : true,
     flipUV : false,
     requires : [ uv0, color ],
-    variables : [ variation, radial, lightv, baked ],
+    variables : [ variation, radial, lightv, leafv ],
     parameters : [
         { type : float4,    name : baseColorFactor },
         { type : sampler2d, name : baseColorMap },
@@ -52,65 +55,12 @@ material {
         { type : sampler2d, name : windNoise },
         { type : float4,    name : plant },
         { type : float4[8], name : benders },
-        { type : float4[8], name : benderMotion },
-        // ---- THE GROUND'S LIGHT (foliage.mat's block, read PER VERTEX here; 2026-10-18, the Forest's baked ground) ----
-        // level-wide, written by creator-gl once a terrain's rect is bound (glb.cpp bindGround / bindOptions)
-        { type : float4,    name : ground, precision : high },
-        { type : float4,    name : groundInv, precision : high },
-        { type : float4,    name : groundST, precision : high },
-        { type : sampler2d, name : lightmapLight, precision : high },
-        { type : sampler2d, name : lightmapAux },
-        { type : float,     name : lightScale },
-        { type : float4,    name : sunDir },
-        { type : float4,    name : sunLight, precision : high },
-        // ---- THE GROUND'S COLOUR (2026-10-18, glb.cpp foliageSetGroundTint): the terrain's control map (its four layers'
-        // weights) and each layer's mean colour; a card's base takes the colour of the soil under it, its top its own
-        { type : sampler2d, name : groundControl },
-        { type : float4[4], name : groundTint },
-        { type : float4,    name : groundTintOrigin, precision : high },   // xy = the terrain's world xz origin, z = bound
-        { type : float4,    name : groundTintInv, precision : high }       // the inverse of its world xz axes
+        { type : float4[8], name : benderMotion }
     ]
 }
 
 vertex {
 #include "foliage-wind.vs"
-#include "lightmap-sunmap.fs"
-
-    // THE GROUND'S LIGHT AT A VERTEX (foliage.mat reads it per pixel, under the pixel): true when the plant stands over
-    // the bound terrain. `ambient` = the terrain texel's irradiance under the vertex without the sun's part (lux, on the
-    // up normal) — the sky through the canopy, the bounce. `sunShare` = the baked share of the sun's disc at the point
-    // where THIS VERTEX'S OWN SUN RAY meets the ground (the plant's base height): what shades that point shades the
-    // vertex too — a neighbour's crown, or the crown above a card deep in it — so a tree past the shadow map's reach
-    // still stands in its neighbour's shadow, and the grass under a pine in the pine's. `lod` picks the pages' level
-    // (a far vertex over one texel of 25 cm would flicker between texels as it sways).
-    // the crowns' level over the ground: a vertex this high takes the open sky's ambient and its own crown's softened shadow
-    #define CANOPY 12.0
-
-    bool groundLightV(highp vec3 uwp, highp float baseY, float lod, out highp vec3 ambient, out float sunShare) {
-        ambient = vec3(0.0); sunShare = 1.0;
-        if (materialParams.ground.z < 0.5) return false;
-        highp vec2 d = uwp.xz - materialParams.ground.xy;
-        highp vec2 g = vec2(dot(materialParams.groundInv.xy, d), dot(materialParams.groundInv.zw, d));
-        if (g.x < 0.0 || g.y < 0.0 || g.x > 1.0 || g.y > 1.0) return false;   // off the terrain
-        highp vec2 luv = g * materialParams.groundST.xy + materialParams.groundST.zw;
-        highp vec3 E = textureLod(materialParams_lightmapLight, luv, lod).rgb * materialParams.lightScale;
-        ambient = E;
-        if (materialParams.sunDir.w > 0.5) {
-            highp ivec2 auxSize = textureSize(materialParams_lightmapAux, 0);
-            highp int level = clamp(int(lod + 0.5), 0, max(sunMapLevels(), 1) - 1);
-            // the sun's part out of the ground's E under the vertex: its illuminance x the share there x the cosine on the
-            // ground, taken as flat
-            float shareHere = sunMapAt(luv, auxSize, level);
-            ambient = max(E - materialParams.sunLight.rgb * (shareHere * max(materialParams.sunDir.y, 0.0)), vec3(0.0));
-            // the sun ray through the vertex, followed down to the plant's base height
-            vec3 s = materialParams.sunDir.xyz;   // TO the sun
-            highp vec3 foot = uwp - s * ((uwp.y - baseY) / max(s.y, 0.05));
-            d = foot.xz - materialParams.ground.xy;
-            g = clamp(vec2(dot(materialParams.groundInv.xy, d), dot(materialParams.groundInv.zw, d)), 0.0, 1.0);
-            sunShare = sunMapAt(g * materialParams.groundST.xy + materialParams.groundST.zw, auxSize, level);
-        }
-        return true;
-    }
 
     vec3 shIrradianceV(const vec3 n) {
         return max(
@@ -129,31 +79,13 @@ vertex {
         float lodEst = max(log2(max(f.dist, 1.0) / 8.0), 0.0);
         material.radial = vec4(f.hull, lodEst);
         // THE LIGHT, per vertex. Ambient = the sky's SH on the hull normal, as radiance under the camera's exposure
-        // (frameUniforms.iblLuminance holds it), darkened by the baked sky visibility by `leaf.w`. The sun = a wrapped
-        // Lambert on the hull (thin leaves let light past the terminator, `sway.w`) plus the translucency of a card lit
-        // from behind (`leaf.z`, narrowed toward the view line into the light; less deep in the crown), one scalar the
-        // fragment multiplies by the light's colour, intensity and SHADOW
+        // (frameUniforms.iblLuminance holds it), darkened by the baked sky visibility by `leaf.w` — the crown's own
+        // depth: a vertex deep in it took less sky in the bake than one on the outside. The sun = a wrapped Lambert on
+        // the hull (thin leaves let light past the terminator, `sway.w`) plus the translucency of a card lit from behind
+        // (`leaf.z`, narrowed toward the view line into the light; less deep in the crown), one scalar the fragment
+        // multiplies by the light's colour, intensity and SHADOW
         float ao = mix(1.0, f.vao, clamp(materialParams.leaf.w, 0.0, 1.0));
-        vec3 skyAmbient = shIrradianceV(f.hull) * frameUniforms.iblLuminance;
-        vec3 ambient = skyAmbient;
-        float sunShare = 1.0;
-        float up = 1.0;   // the vertex's height over the ground as a share of the canopy's (1 without a ground)
-        highp vec3 gAmb;
-        if (groundLightV(f.uwp, f.uOrigin.y, lodEst, gAmb, sunShare)) {
-            // THE BAKED GROUND'S LIGHT (the function above): its ambient on the hull normal by the hemisphere formula
-            // lightmapShade uses for a tilted normal (the light comes from above), as radiance E / pi under the camera's
-            // exposure. The crown's base takes the ground's ambient (the sky through the canopy), its top the open sky's
-            // SH - blended by the vertex's height over the plant; a grass blade is all ground
-            // the hemisphere formula alone gave a down-facing hull nothing (black needles under a young pine, the owner
-            // 2026-10-18): what a card sees below is the ground, lit by that same E and reflecting a quarter of it
-            vec3 groundAmbient = gAmb * mix(0.25, 1.0, (1.0 + f.hull.y) * 0.5) / PI * frameUniforms.exposure;
-            // by the height OVER THE GROUND, not within the plant: a bush's top is under the same crowns as the ground
-            // beside it (a 1.5 m bush with the open sky's SH on its top was a lamp in the shade - the owner, 2026-10-18);
-            // the open sky is reached at the crowns' level, CANOPY metres up
-            up = clamp((f.uwp.y - f.uOrigin.y) / CANOPY, 0.0, 1.0);
-            ambient = mix(groundAmbient, skyAmbient, up);
-        }
-        ambient *= ao;
+        vec3 ambient = shIrradianceV(f.hull) * frameUniforms.iblLuminance * ao;
         vec3 l = frameUniforms.lightDirection;
         vec3 v = normalize(getWorldCameraPosition() - f.wp);
         float wrap = clamp(materialParams.sway.w, 0.0, 1.0);
@@ -162,36 +94,11 @@ vertex {
         float vl = pow(max(dot(-v, l), 0.0), 4.0);
         float through = clamp(materialParams.leaf.z, 0.0, 1.0) * back * (0.5 + 0.5 * vl) * mix(1.0, f.vao, 0.5);
         material.lightv = vec4(ambient, NoL);
-        // .x = the baked share of the sun at this vertex (1 without a bound ground): surfaceShading takes it as a second
-        // shadow map on the direct light, the stricter of the two, never the product. .y = the translucency, which takes
-        // the shadow map ALONE: the bake's 64-ray share through the crown put out the glow of a back-lit crown (the
-        // multiple scattering a real crown has and this model lacks; the owner, 2026-10-18 "лес довольно тёмный")
-        // .z = the height share: near the ground a shadow is a NEIGHBOUR's and lands in full, at the crowns' level it is the
-        // crown's own and is softened by leaf.y (the scattering a real crown has); the fragment weighs the shadow by it.
+        material.variation = vec4(f.hash, f.alive, f.tintN, 0.0);
+        // .x = the translucency scalar (the fragment multiplies it by the light and its shadow, like NoL)
         // (The plants' SHADOW LOD is the LOD pass's, per renderable - lod.cpp gFoliageCast - not this shader's: a card-level
         // discard in the depth variant saved 0.6 ms of the pass's 6.8, the renderables' vertices and draws are the cost)
-        // THE GROUND'S COLOUR at the plant's base: the layers' weights under the PLANT (one colour per plant - a varying
-        // that differs per vertex could not carry a packed value) times their mean colours; the fragment blends the card's
-        // colour toward it by `baked.w` - all of it at the ground, none from ~70 % of the plant's height up (a grass
-        // blade's base is its soil, a bush's crown its own leaves; a tree's cards never reach it). The colour rides
-        // `variation.w` packed 7 bits a channel (matc allows four variables with the colour attribute; vao was unused there)
-        float gtPacked = 0.0, gtBlend = 0.0;
-        if (materialParams.groundTintOrigin.z > 0.5) {
-            highp vec2 td = f.uOrigin.xz - materialParams.groundTintOrigin.xy;
-            highp vec2 tg = vec2(dot(materialParams.groundTintInv.xy, td), dot(materialParams.groundTintInv.zw, td));
-            if (tg.x >= 0.0 && tg.y >= 0.0 && tg.x <= 1.0 && tg.y <= 1.0) {
-                vec4 w = textureLod(materialParams_groundControl, tg, 0.0);
-                float ws = max(w.x + w.y + w.z + w.w, 1e-3);
-                vec3 soil = (materialParams.groundTint[0].rgb * w.x + materialParams.groundTint[1].rgb * w.y
-                           + materialParams.groundTint[2].rgb * w.z + materialParams.groundTint[3].rgb * w.w) / ws;
-                float base = 1.0 - clamp((f.uwp.y - f.uOrigin.y) / max(0.7 * f.plantH, 0.05), 0.0, 1.0);
-                vec3 q = floor(clamp(soil, 0.0, 1.0) * 127.0 + 0.5);
-                gtPacked = q.r * 16384.0 + q.g * 128.0 + q.b;
-                gtBlend = base * 0.85;
-            }
-        }
-        material.variation = vec4(f.hash, f.alive, f.tintN, gtPacked);
-        material.baked = vec4(sunShare, through, up, gtBlend);
+        material.leafv = vec4(through, 0.0, 0.0, 0.0);
     }
 }
 
@@ -203,12 +110,6 @@ fragment {
         float hash = variable_variation.x;
         vec3 tint = mix(vec3(0.86, 0.94, 0.72), vec3(1.06, 1.02, 1.12), hash);
         base.rgb *= mix(vec3(1.0), tint, materialParams.sway.z) * (1.0 - 0.18 * variable_variation.z);
-        // the ground's colour at the base (the vertex shader's note): the soil's mean colour in place of the card's
-        if (variable_baked.w > 0.0) {
-            highp float pk = variable_variation.w;
-            vec3 soil = vec3(floor(pk / 16384.0), mod(floor(pk / 128.0), 128.0), mod(pk, 128.0)) / 127.0;
-            base.rgb = mix(base.rgb, soil, variable_baked.w);
-        }
         // the distance fade thins the card; the coverage holds a far crown's share over the cutoff (colour pass only:
         // the shadow map's caster is fattened below already)
         base.a *= variable_variation.y;
@@ -227,25 +128,12 @@ fragment {
     }
 
     // PER LIGHT (the sun first): the vertex shader's wrapped Lambert + translucency scalar, times the light and its
-    // SHADOW (a card takes the shadow map by leaf.y only, foliage.mat's rule). The shadow is the STRICTER of the
-    // shadow map's and the baked ground's share at the vertex (groundLightV): past the map's reach the bake alone,
-    // within it the two agree on the same crowns and the min keeps them from doubling. A lamp gets the sun's scalar
-    // too — the lean tier is for cards seen from a distance, where a lamp's own angle on a leaf is not read
+    // SHADOW. A card takes the shadow map by leaf.y only (foliage.mat's rule): the map cannot tell a neighbour's shadow
+    // from the crown's own card-on-card one, and a young pine at full strength went black (2026-10-18). A lamp gets the
+    // sun's scalar too — the lean tier is for cards seen from a distance, where a lamp's own angle on a leaf is not read
     vec3 surfaceShading(const MaterialInputs materialInputs, const ShadingData shadingData, const LightData lightData) {
-        // the shadow MAP is always softened by leaf.y: it cannot tell a neighbour's shadow from the crown's own card-on-card
-        // one, and a young pine at full strength went black (2026-10-18). The BAKED share can: a neighbour's crown is in it
-        // through 64 alpha-tested rays, so it lands in full near the ground and softens to leaf.y at the crowns' level
-        float ky = clamp(materialParams.leaf.y, 0.0, 1.0);
-        float kB = mix(1.0, ky, variable_baked.z);
-        // the baked share is the SUN's: a lamp takes its own shadow map alone (foliage.mat's test for the sun)
-        bool sun = dot(lightData.l, frameUniforms.lightDirection) > 0.999;
-        float baked = sun ? mix(1.0, variable_baked.x, kB) : 1.0;
-        float lit = min(mix(1.0, lightData.visibility, ky), baked);   // the direct light
-        // the translucency takes the same two shadows at the HEIGHT weight (kB): a blade at the ground in a tree's baked shade
-        // gets none of the sun through it (the map alone leaked 30-40 % of the sun into every shaded clump, and all of it past
-        // castDistance - the owner, 2026-10-18 "трава светлая в тени"); a card at the crowns' level keeps leaf.y of it
-        float litT = sun ? mix(1.0, min(lightData.visibility, variable_baked.x), kB) : mix(1.0, lightData.visibility, ky);
-        float reach = lightData.colorIntensity.w * lightData.attenuation;
-        return shadingData.diffuseColor * lightData.colorIntensity.rgb * (reach * (lit * variable_lightv.w + litT * variable_baked.y) / PI);
+        float lit = mix(1.0, lightData.visibility, clamp(materialParams.leaf.y, 0.0, 1.0));
+        float reach = lightData.colorIntensity.w * lightData.attenuation * lit;
+        return shadingData.diffuseColor * lightData.colorIntensity.rgb * (reach * (variable_lightv.w + variable_leafv.x) / PI);
     }
 }