lecodes-cli 1.0.0 → 2.0.0

package/runtime/materials/terrain.mat

@@ -4,21 +4,26 @@
 // terrain's local XZ in metres (creator-gl/src/terrain.cpp writes it), so `tiling` reads as metres
 // per repeat and the control map is addressed as (uv / cellSize + 0.5) / gridSize.
 //
+// ROUGHNESS: a layer's is its `roughness` factor x the ALPHA of its albedo - the one free channel the sampler budget
+// leaves (ground is opaque). An albedo without alpha reads 1, so the factor alone stands; with a roughness map packed
+// into the alpha a wet patch or a trodden path shines inside one layer. No metallic: ground is a dielectric.
+//
 // Sampler budget: feature level 1 (every host, WebGL included) allows 9 samplers per material, so the
 // normal maps come PACKED two per texture — normals01 = (layer 0 XY in RG, layer 1 XY in BA),
 // normals23 likewise; Z is reconstructed. `lecodes assets` packs them; an unset pack (the shared
 // 1x1 white) decodes to a flat normal, and normalScale 0 skips the read.
 //
-// Baked lighting: lightmap.mat's atlas block (R = sun visibility, G = AO on UV1 = the terrain's ONE
-// atlas rect; the light volume for movers is not needed — a terrain never moves), so a baked level
-// applies the atlas to this material directly, no swap. Every sampler defaults to the shared 1x1
-// white (applyIdentityDefaults): an unset layer is white, an unset lightmap is "fully lit".
+// Baked lighting: none yet in the rewritten bake (2026-09-16) — a terrain is lit real-time; the
+// creator-bake atlas comes back to this material in a later phase.
 material {
     name : terrain,
     shadingModel : lit,
+    // geometric specular AA (Kaplanyan): the ground is a 1024² normal map at ×1.5–2 tiled every 2 m under a
+    // 100 000 lux sun — without this every minified texel is a sub-pixel mirror and the sand sparkles
+    // (Mountain, 2026-09-23; A/B with normalScale 0 showed nothing but the normal map does it)
+    specularAntiAliasing : true,
     flipUV : false,
     requires : [ uv0, uv1 ],
-    postLightingBlending : multiply,
     parameters : [
         { type : sampler2d, name : control },
         { type : sampler2d, name : albedo0 },
@@ -37,37 +42,36 @@ material {
         // samples along X and Z
         { type : float2,    name : gridSize },
         { type : float,     name : cellSize },
-        { type : float3,    name : tint },
-        { type : sampler2d, name : lightmap },
-        // the point lights' baked irradiance, sRGB(E / lightScale), same rect; lightScale 0 = none (the 9th sampler)
-        { type : sampler2d, name : lightmapLight },
-        { type : float,     name : lightScale },
-        // the light store's curve: texel = sRGB(pow(E / lightScale, 1 / lightGamma)); 0/1 = linear (v2 bakes), 2 = the square-root store
-        { type : float,     name : lightGamma },
-        { type : float4,    name : lightmapST },
-        { type : float,     name : ambientScale },
-        { type : float,     name : sunStrength },
-        // how much of the baked ambient occlusion applies (1 = all)
-        { type : float,     name : bakedAo }
+        { type : float3,    name : tint }
     ]
 }
 
 fragment {
-    vec4 triplanarSample(sampler2D tex, vec3 p, vec3 bw, float s) {
+    // highp THROUGHOUT THE UV MATH. UV0 is the terrain's XZ IN METRES, so it runs to the plot's size
+    // (128 m here) — and the macOS / iOS materials are compiled for the MOBILE profile, where a
+    // fragment shader's default float is mediump = half on an Apple GPU. A half holds ~11 bits of
+    // mantissa, so at 64..128 m it steps by 6..12 cm: the ground came out as flat square patches of
+    // that size, whatever the texture (measured 2026-09-20 on Peremena — sharp in the WebGL host,
+    // which has no mediump, and sharp on a plain lit quad, whose UVs are 0..1).
+    vec4 triplanarSample(sampler2D tex, highp vec3 p, vec3 bw, float s) {
         return texture(tex, p.zy / s) * bw.x + texture(tex, p.xz / s) * bw.y + texture(tex, p.xy / s) * bw.z;
     }
 
     // `slot` 0 = this layer's normal XY sits in the pack's RG, 1 = in its BA
     void splatLayer(sampler2D alb, sampler2D pack, float slot, float tiling, float nscale, float tri, float w,
-                    vec2 uv, vec3 wp, vec3 bw, inout vec3 albedo, inout vec3 nrm) {
+                    highp vec2 uv, highp vec3 wp, vec3 bw, float rf, inout vec3 albedo, inout vec3 nrm, inout float rough) {
         if (w <= 0.0) return;
         float s = max(tiling, 1e-3);
         if (tri > 0.5) {
-            albedo += triplanarSample(alb, wp, bw, s).rgb * w;
+            vec4 c = triplanarSample(alb, wp, bw, s);
+            albedo += c.rgb * w;
+            rough += rf * c.a * w;
             nrm += vec3(0.0, 0.0, 1.0) * w;
         } else {
-            vec2 luv = uv / s;
-            albedo += texture(alb, luv).rgb * w;
+            highp vec2 luv = uv / s;
+            vec4 c = texture(alb, luv);
+            albedo += c.rgb * w;
+            rough += rf * c.a * w;
             if (nscale > 0.0) {
                 vec4 p = texture(pack, luv);
                 vec2 xy = (slot > 0.5 ? p.ba : p.rg) * 2.0 - 1.0;
@@ -81,54 +85,31 @@ fragment {
     }
 
     void material(inout MaterialInputs material) {
-        vec2 uv = getUV0();
-        vec2 cuv = (uv / max(materialParams.cellSize, 1e-4) + 0.5) / max(materialParams.gridSize, vec2(1.0));
+        highp vec2 uv = getUV0();
+        highp vec2 cuv = (uv / max(materialParams.cellSize, 1e-4) + 0.5) / max(materialParams.gridSize, vec2(1.0));
         vec4 w = texture(materialParams_control, cuv);
         float ws = w.r + w.g + w.b + w.a;
         w = ws > 1e-4 ? w / ws : vec4(1.0, 0.0, 0.0, 0.0);
 
-        vec3 wp = getUserWorldPosition();
+        highp vec3 wp = getUserWorldPosition();
         vec3 gn = getWorldGeometricNormalVector();
         vec3 bw = abs(gn);
         bw = bw / max(bw.x + bw.y + bw.z, 1e-4);
 
         vec3 albedo = vec3(0.0);
         vec3 nrm = vec3(0.0);
-        splatLayer(materialParams_albedo0, materialParams_normals01, 0.0, materialParams.tiling.x, materialParams.normalScale.x, materialParams.triplanar.x, w.r, uv, wp, bw, albedo, nrm);
-        splatLayer(materialParams_albedo1, materialParams_normals01, 1.0, materialParams.tiling.y, materialParams.normalScale.y, materialParams.triplanar.y, w.g, uv, wp, bw, albedo, nrm);
-        splatLayer(materialParams_albedo2, materialParams_normals23, 0.0, materialParams.tiling.z, materialParams.normalScale.z, materialParams.triplanar.z, w.b, uv, wp, bw, albedo, nrm);
-        splatLayer(materialParams_albedo3, materialParams_normals23, 1.0, materialParams.tiling.w, materialParams.normalScale.w, materialParams.triplanar.w, w.a, uv, wp, bw, albedo, nrm);
+        float rough = 0.0;
+        splatLayer(materialParams_albedo0, materialParams_normals01, 0.0, materialParams.tiling.x, materialParams.normalScale.x, materialParams.triplanar.x, w.r, uv, wp, bw, materialParams.roughness.x, albedo, nrm, rough);
+        splatLayer(materialParams_albedo1, materialParams_normals01, 1.0, materialParams.tiling.y, materialParams.normalScale.y, materialParams.triplanar.y, w.g, uv, wp, bw, materialParams.roughness.y, albedo, nrm, rough);
+        splatLayer(materialParams_albedo2, materialParams_normals23, 0.0, materialParams.tiling.z, materialParams.normalScale.z, materialParams.triplanar.z, w.b, uv, wp, bw, materialParams.roughness.z, albedo, nrm, rough);
+        splatLayer(materialParams_albedo3, materialParams_normals23, 1.0, materialParams.tiling.w, materialParams.normalScale.w, materialParams.triplanar.w, w.a, uv, wp, bw, materialParams.roughness.w, albedo, nrm, rough);
         material.normal = normalize(nrm);
         prepareMaterial(material);
 
         material.baseColor = vec4(albedo * materialParams.tint, 1.0);
-        material.roughness = dot(materialParams.roughness, w);
+        material.roughness = rough;
         material.metallic = 0.0;
 
-        // ---- baked lighting (lightmap.mat's atlas block) ----
-        vec3 n = gn;
-        vec2 luv = getUV1() * materialParams.lightmapST.xy + materialParams.lightmapST.zw;
-        vec2 lm = texture(materialParams_lightmap, luv).rg;
-        lm.g = mix(1.0, lm.g, materialParams.bakedAo);
-        material.ambientOcclusion = lm.g;
-        // the point lights' baked diffuse (lightmap.mat's emissive path; the terrain has no glTF emissive)
-        float lg = materialParams.lightGamma > 0.0 ? materialParams.lightGamma : 1.0;
-        vec3 baked = pow(texture(materialParams_lightmapLight, luv).rgb, vec3(lg)) * materialParams.lightScale;
-        material.emissive = vec4(material.baseColor.rgb * baked * (getExposure() / PI), 0.0);
-
-        float vis = mix(1.0, lm.r, materialParams.sunStrength);
-        vec3 sh = 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);
-        vec3 luma = vec3(0.2126, 0.7152, 0.0722);
-        float amb = max(dot(max(sh, 0.0), luma), 0.0) * frameUniforms.iblLuminance * materialParams.ambientScale * lm.g;
-        float nol = max(dot(n, frameUniforms.lightDirection), 0.0);
-        float sun = dot(frameUniforms.lightColorIntensity.rgb, luma) * frameUniforms.lightColorIntensity.w * nol / PI;
-        // the baked lamps ride the emissive slot the multiply scales too: same share on both sides
-        float lamp = dot(baked, luma) * (getExposure() / PI);
-        float k = (amb + sun * vis + lamp) / max(amb + sun + lamp, 1e-6);
-        material.postLightingColor = vec4(k, k, k, 1.0);
+        material.ambientOcclusion = 1.0;
     }
 }