@driftengine/core 4.11.1 → 4.12.0

package/dist/render/shaders/flat/layered.js

@@ -1,8 +1,10 @@
+import { layerLooksGlsl } from './layerLooks.js';
 /**
  * A material blended from layers by a mask: `SurfaceMaterial.layers`, packed into `uLayers` by
  * `surfaceLayers.ts`.
  *
- * **Layer `i` is layer `i` of the material's arrays**, each read at its own repeat of where the
+ * **Layer `i` is layer `i` of the material's arrays** — or the layer `layerLooks.ts` picks, with the
+ * tint, ranges and normal strength it gives each — each read at its own repeat of where the
  * layers are laid: the mesh's coordinates, or the world's horizontal plane where the material has a
  * projection (`worldUv.ts`). The mask's channels weigh layers 1 to 4 — red, green, blue, alpha — and
  * come from a map read where a shading model's would be, from the ORM array's layer past the layers,
@@ -21,10 +23,11 @@
  * in uniform control flow (AGENTS.md 2026-08-07), so the loop is bounded by the layer count, a
  * uniform, and never skips on a share, which is the pixel's own.
  *
- * **A lit switch, `LAYERED`**, off until a material first asks, declared last so every switch before
- * it keeps its id. Compiled out, its four vectors are not declared and its calls are constants.
+ * **A lit switch, `LAYERED`**, off until a material first asks, declared after every switch before
+ * it so each keeps its id. Compiled out, its four vectors are not declared and its calls are
+ * constants. `looks` compiles `LAYER_LOOKS` in beside it, and means nothing without it.
  */
-export function layeredGlsl(on) {
+export function layeredGlsl(on, looks = false) {
     if (!on) {
         return /* glsl */ `
 const bool LAYERED = false;  // wgsl:override
@@ -38,6 +41,8 @@ bool layeredMeshNormal() { return false; }
 vec3 layeredMeshTexel() { return vec3(0.0, 0.0, 1.0); }
 bool layeredGlows() { return false; }
 vec3 layeredEmissive() { return vec3(0.0); }
+float layeredAmbient() { return 1.0; }
+float layeredSpecular(float own) { return own; }
 `;
     }
     return /* glsl */ `
@@ -51,10 +56,12 @@ const bool LAYERED = true;  // wgsl:override
  * layer or -1 (y), its bias (z) and its sharpness (w).
  */
 uniform vec4 uLayers[4]; // wgsl:material
-
+${layerLooksGlsl(looks)}
 /* Each layer's share of this point, the base's and layers 1 to 4's: worked out once, in layeredBegin. */
 float lShareBase;
 vec4 lShare;
+/* What an occlusion read at the mesh's coordinates leaves of this point, 1 where none: layeredBegin. */
+float lMeshOcclusion;
 
 bool layered() {
   return uLayers[1].y > 0.5;
@@ -71,14 +78,15 @@ vec2 layerPlace() {
 }
 
 vec3 layerAt(int i) {
-  return vec3(layerPlace() * layerRepeat(i), float(i));
+  float across = layerRepeat(i);
+  return vec3(layerPlace() * vec2(across, layerRepeatDown(i, across)), layerArray(i));
 }
 
 /* The weights as the material keeps them: the mask's channels, at the mesh's own coordinates. */
 vec4 layerWeights() {
   float source = uLayers[1].w;
   if (source > 1.5) return vec4(vColor, 0.0);
-  if (source > 0.5) return texture(uOrmMap, vec3(vUv.xy, uLayers[1].y));
+  if (source > 0.5) return texture(uOrmMap, vec3(vUv.xy, layerExtras()));
   return texture(uModelMap, vec3(vUv.xy, 0.0));
 }
 
@@ -92,10 +100,22 @@ vec4 layerPick(float layer) {
  * Under a branch on uniforms, as its reads are.
  */
 void layeredBegin() {
+  /*
+   * The occlusion at the mesh's coordinates, once: the ORM array's layer past the layers and past
+   * any mask and added mask it carries, spread over its range and taken at its strength.
+   */
+  lMeshOcclusion = 1.0;
+  float strength = layerOcclusionStrength();
+  if (strength > 0.0) {
+    float at = layerExtras() + (abs(uLayers[1].w - 1.0) < 0.5 ? 1.0 : 0.0) + (uLayers[2].z > 0.5 ? 1.0 : 0.0);
+    vec2 range = layerOcclusionRange();
+    float occlusion = mix(range.x, range.y, texture(uOrmMap, vec3(vUv.xy, at)).r);
+    lMeshOcclusion = mix(1.0, occlusion, strength);
+  }
   vec4 m = layerWeights();
   if (uLayers[2].z > 0.5) {
     /* The ORM array's layer past the layers, and past the mask where the array carries that too. */
-    float at = uLayers[1].y + (abs(uLayers[1].w - 1.0) < 0.5 ? 1.0 : 0.0);
+    float at = layerExtras() + (abs(uLayers[1].w - 1.0) < 0.5 ? 1.0 : 0.0);
     float added = texture(uOrmMap, vec3(layerPlace() * uLayers[2].w, at)).r * uLayers[3].x;
     m = mix(m, clamp(m + added, 0.0, 1.0), layerPick(uLayers[2].z));
   }
@@ -135,23 +155,52 @@ vec3 layeredColor(vec3 color) {
   return uLayers[1].w > 1.5 ? vec3(1.0) : color;
 }
 
-/* Colour by the shares, and the base layer's coverage, which a cutout reads. */
+/*
+ * Colour by the shares, each layer's tinted, and the base layer's coverage, which a cutout reads;
+ * then darkened by the occlusion at the mesh's coordinates, where it is the colour that takes it.
+ */
 vec4 layeredAlbedo() {
   vec4 sum = vec4(0.0);
   for (int i = 0; i < 5; i++) {
     if (float(i) >= uLayers[1].y) break;
     vec4 t = texture(uAlbedo, layerAt(i));
-    sum.rgb += t.rgb * layerShare(i);
+    sum.rgb += t.rgb * layerTint(i) * layerShare(i);
     if (i == 0) sum.a = t.a;
   }
+  if (!layerOcclusionAmbient()) sum.rgb *= lMeshOcclusion;
   return sum;
 }
 
+/* What the ambient light keeps: the occlusion at the mesh's coordinates, where it takes it. */
+float layeredAmbient() {
+  return layerOcclusionAmbient() ? lMeshOcclusion : 1.0;
+}
+
+/*
+ * The specular by the shares, each layer's own or the surface's where it names none. The surface's
+ * own, untouched, where no material has asked for looks: shares summing to one in floating point
+ * are not quite one, and a layered material that names nothing must draw exactly as before.
+ */
+float layeredSpecular(float own) {
+  if (LAYER_LOOKS) {
+    float sum = 0.0;
+    for (int i = 0; i < 5; i++) {
+      if (float(i) >= uLayers[1].y) break;
+      sum += layerSpecular(i, own) * layerShare(i);
+    }
+    return sum;
+  }
+  return own;
+}
+
+/* Occlusion, roughness and metalness by the shares, each layer's spread over its own ranges. */
 vec3 layeredOrm() {
   vec3 sum = vec3(0.0);
   for (int i = 0; i < 5; i++) {
     if (float(i) >= uLayers[1].y) break;
-    sum += texture(uOrmMap, layerAt(i)).rgb * layerShare(i);
+    vec3 t = texture(uOrmMap, layerAt(i)).rgb;
+    t.yz = layerRanges(i, t.yz);
+    sum += t * layerShare(i);
   }
   return sum;
 }
@@ -168,7 +217,7 @@ vec3 layeredTexel() {
   vec3 sum = vec3(0.0);
   for (int i = 0; i < 5; i++) {
     if (float(i) >= uLayers[1].y) break;
-    sum += layerNormalTexel(layerAt(i)) * layerShare(i);
+    sum += layerStrengthen(i, layerNormalTexel(layerAt(i))) * layerShare(i);
   }
   float len = length(sum);
   return len > 1e-5 ? sum / len : vec3(0.0, 0.0, 1.0);
@@ -181,7 +230,7 @@ bool layeredMeshNormal() {
 
 /* That normal's texel: the normal array's layer past the layers, at the mesh's coordinates. */
 vec3 layeredMeshTexel() {
-  return layerNormalTexel(vec3(vUv.xy, uLayers[1].y));
+  return layerNormalTexel(vec3(vUv.xy, layerExtras()));
 }
 
 /* Whether the emissive map belongs to one layer rather than to the whole surface. */