@driftengine/core 4.10.0 → 4.11.1

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

@@ -29,13 +29,56 @@ export const DIRECTIONALSHADOW_GLSL = `vec2 receiverPlaneDepthGradient(vec3 p) {
   );
 }
 
-float directionalVisibility(float receiverDepth, float compareDepth, float storedDepth) {
+/* One stored depth against a receiver, in a map spanning \`span\` metres of depth. */
+float directionalVisibilityAt(float receiverDepth, float compareDepth, float storedDepth, float span) {
   if (compareDepth <= storedDepth) return 1.0;
-  float rayDistance = max(receiverDepth - storedDepth, 0.0) * uShadowDepthSpan;
+  float rayDistance = max(receiverDepth - storedDepth, 0.0) * span;
   float groundDistance = rayDistance * length(uDirectionalDir.xz);
   return 1.0 - shadowReach(groundDistance, uShadowMaxDistance);
 }
 
+float directionalVisibility(float receiverDepth, float compareDepth, float storedDepth) {
+  return directionalVisibilityAt(receiverDepth, compareDepth, storedDepth, uShadowDepthSpan);
+}
+
+/* How far inside its square a receiver stands in a layer's map: 1 well inside, 0 at its border. */
+float sunMapFade(vec3 p) {
+  if (p.z > 1.0 || p.x < 0.0 || p.x > 1.0 || p.y < 0.0 || p.y > 1.0) return 0.0;
+  vec2 fromCentre = abs(p.xy - 0.5) * 2.0;
+  return (1.0 - smoothstep(0.72, 0.98, max(fromCentre.x, fromCentre.y))) *
+    (1.0 - smoothstep(0.90, 1.0, p.z));
+}
+
+/*
+ * The moving layer at its own place, where it has a matrix of its own (movingSun.ts): the coarse
+ * test of shadowFactor, and its filter, each against the moving map's own depth span, and lit by
+ * how far inside the moving map's square the receiver stands rather than cut at its border.
+ */
+float movingSunCoarse(vec3 pm, float span) {
+  float inside = sunMapFade(pm);
+  if (inside <= 0.0) return 1.0;
+  float stored = textureLod(uSunShadows, vec3(pm.xy, ${SUN_DYNAMIC_LAYER}.0), 0.0).r;
+  return mix(1.0, directionalVisibilityAt(pm.z, pm.z - 1.0 / span, stored, span), inside);
+}
+
+float movingSunFiltered(vec3 pm, vec2 gradient, float span) {
+  float inside = sunMapFade(pm);
+  if (inside <= 0.0) return 1.0;
+  float texel = 1.35 / uShadowMapSize;
+  float slopeLimit = 9.1 / uShadowMapSize;
+  float lit = 0.0;
+  for (int i = 0; i < ${MAX_SHADOW_FILTER_TAPS}; i++) {
+    if (i >= uShadowFilterTaps) break;
+    vec2 sampleUv = pm.xy + DIRECTIONAL_PCF_OFFSETS[i] * texel;
+    vec2 texelCentre = (floor(sampleUv * uShadowMapSize) + 0.5) / uShadowMapSize;
+    float slopeOffset = clamp(dot(gradient, texelCentre - pm.xy), -slopeLimit, slopeLimit);
+    float tapReceiverDepth = pm.z + slopeOffset;
+    float stored = textureLod(uSunShadows, vec3(sampleUv, ${SUN_DYNAMIC_LAYER}.0), 0.0).r;
+    lit += directionalVisibilityAt(tapReceiverDepth, tapReceiverDepth - 0.14 / span, stored, span);
+  }
+  return mix(1.0, lit / float(max(uShadowFilterTaps, 1)), inside);
+}
+
 float shadowFactor(float directionalNdl) {
   if (uShadowStrength <= 0.0) return 1.0;
 
@@ -65,6 +108,14 @@ float shadowFactor(float directionalNdl) {
   vec3 p = vLightPos.xyz / vLightPos.w;
   p = p * 0.5 + 0.5;
   vec2 depthGradient = receiverPlaneDepthGradient(p);
+  /* The moving layer's own place and plane where it has a matrix of its own (movingSun.ts), taken
+     here beside the static layer's for the same reason: above every varying-dependent return. */
+  vec3 pm = p;
+  vec2 movingGradient = depthGradient;
+  if (MOVING_SUN) {
+    pm = movingSunAt();
+    movingGradient = receiverPlaneDepthGradient(pm);
+  }
 
   // Near a surface's own light terminator its direct-light term is already
   // approaching zero, while the orthographic projection of that surface
@@ -129,7 +180,8 @@ float shadowFactor(float directionalNdl) {
   float coarseCompare = p.z - 1.0 / uShadowDepthSpan;
   float coarse =
     directionalVisibility(p.z, coarseCompare, textureLod(uSunShadows, vec3(p.xy, ${SUN_STATIC_LAYER}.0), 0.0).r) *
-    directionalVisibility(p.z, coarseCompare, textureLod(uSunShadows, vec3(p.xy, ${SUN_DYNAMIC_LAYER}.0), 0.0).r);
+    (MOVING_SUN ? movingSunCoarse(pm, movingSunSpan()) :
+      directionalVisibility(p.z, coarseCompare, textureLod(uSunShadows, vec3(p.xy, ${SUN_DYNAMIC_LAYER}.0), 0.0).r));
   if (uPeeledShadowEnabled != 0) {
     coarse *= directionalVisibility(p.z, coarseCompare, textureLod(uSunShadows, vec3(p.xy, ${SUN_PEELED_LAYER}.0), 0.0).r);
   }
@@ -193,7 +245,6 @@ float shadowFactor(float directionalNdl) {
      * there is no mip to select and level zero is the only thing \`texture\` could have read.
      */
     float staticDepth = textureLod(uSunShadows, vec3(sampleUv, ${SUN_STATIC_LAYER}.0), 0.0).r;
-    float dynamicDepth = textureLod(uSunShadows, vec3(sampleUv, ${SUN_DYNAMIC_LAYER}.0), 0.0).r;
     staticLit += directionalVisibility(tapReceiverDepth, compare, staticDepth);
     if (uPeeledShadowEnabled != 0) {
       float peeledDepth = textureLod(uSunShadows, vec3(sampleUv, ${SUN_PEELED_LAYER}.0), 0.0).r;
@@ -201,12 +252,18 @@ float shadowFactor(float directionalNdl) {
     } else {
       peeledLit += 1.0;
     }
-    dynamicLit += directionalVisibility(tapReceiverDepth, compare, dynamicDepth);
+    /* The moving layer here where it shares the static one's place; at its own below otherwise.
+       Branched on the switch itself, never its negation: see overridableConstants in transform.mjs. */
+    if (MOVING_SUN) {
+    } else {
+      float dynamicDepth = textureLod(uSunShadows, vec3(sampleUv, ${SUN_DYNAMIC_LAYER}.0), 0.0).r;
+      dynamicLit += directionalVisibility(tapReceiverDepth, compare, dynamicDepth);
+    }
   }
   float tapCount = float(max(uShadowFilterTaps, 1));
   staticLit /= tapCount;
   peeledLit /= tapCount;
-  dynamicLit /= tapCount;
+  dynamicLit = MOVING_SUN ? movingSunFiltered(pm, movingGradient, movingSunSpan()) : dynamicLit / tapCount;
 
   // Independent layers preserve every recorded fact at an overlap: each
   // caster keeps its own distance fade, and their transmissions compose
@@ -227,11 +284,11 @@ float shadowFactor(float directionalNdl) {
  * behind the receiver lending it colour within the spread, which only a receiver between two panes
  * meets. One function for both layers, because two copies were most of the lit shaders' growth.
  */
-vec3 sunGlassLayer(vec3 p, float paneLayer, float tintLayer, float bias, float texel, float uvPerMetre) {
+vec3 sunGlassLayer(vec3 p, float paneLayer, float tintLayer, float bias, float texel, float uvPerMetre, float span) {
   float tintSize = float(textureSize(uSunGlassTints, 0).x);
   float clarity = textureLod(uSunGlassTints, vec3(p.xy, tintLayer), 0.0).a;
   float behind =
-    max(p.z - textureLod(uSunShadows, vec3(p.xy, paneLayer), 0.0).r, 0.0) * uShadowDepthSpan;
+    max(p.z - textureLod(uSunShadows, vec3(p.xy, paneLayer), 0.0).r, 0.0) * span;
   float radius = clamp(
     (1.0 - clarity) * ${FROST_SPREAD.toFixed(6)} * behind * uvPerMetre,
     texel,
@@ -271,6 +328,13 @@ vec3 sunGlassLookup(float directionalNdl) {
   /* Map units per metre along the receiver, from derivatives taken first in uniform control flow,
      so a frost spread stated in metres lands the same whatever size of light matrix a consumer built. */
   float uvPerMetre = length(dFdx(p.xy)) / max(length(dFdx(vWorldPos)), 1e-6);
+  /* The moving glass at its own place where its layer has a matrix of its own: movingSun.ts. */
+  vec3 pm = p;
+  float movingPerMetre = uvPerMetre;
+  if (MOVING_SUN) {
+    pm = movingSunAt();
+    movingPerMetre = length(dFdx(pm.xy)) / max(length(dFdx(vWorldPos)), 1e-6);
+  }
   if (uShadowStrength <= 0.0 || textureSize(uSunGlassTints, 0).x <= 1) return vec3(1.0);
   if (directionalNdl <= 0.0) return vec3(1.0);
   if (p.z > 1.0 || p.x < 0.0 || p.x > 1.0 || p.y < 0.0 || p.y > 1.0) return vec3(1.0);
@@ -288,8 +352,18 @@ vec3 sunGlassLookup(float directionalNdl) {
 
   float bias = 0.14 / uShadowDepthSpan;
   float texel = 1.35 / uShadowMapSize;
-  vec3 staticTint = sunGlassLayer(p, ${SUN_GLASS_STATIC_LAYER}.0, 0.0, bias, texel, uvPerMetre);
-  vec3 movingTint = sunGlassLayer(p, ${SUN_GLASS_MOVING_LAYER}.0, 1.0, bias, texel, uvPerMetre);
+  vec3 staticTint = sunGlassLayer(p, ${SUN_GLASS_STATIC_LAYER}.0, 0.0, bias, texel, uvPerMetre, uShadowDepthSpan);
+  vec3 movingTint = MOVING_SUN && sunMapFade(pm) <= 0.0
+    ? vec3(1.0)
+    : sunGlassLayer(
+      pm,
+      ${SUN_GLASS_MOVING_LAYER}.0,
+      1.0,
+      MOVING_SUN ? 0.14 / movingSunSpan() : bias,
+      texel,
+      movingPerMetre,
+      MOVING_SUN ? movingSunSpan() : uShadowDepthSpan
+    );
   return mix(vec3(1.0), staticTint * movingTint, strength);
 }
 

package/dist/render/shaders/flat/glassTint.d.ts

@@ -8,7 +8,7 @@ export declare function glassTintGlsl(glassShadows: boolean): string;
  * The lit stage's switches, by the name of the constant each is: the decision both backends make
  * about which optional code a lit program carries. See `litSwitchesGlsl`.
  */
-export type LitSwitch = 'GLASS_SHADOWS' | 'CLUSTERED_LIGHTS' | 'LIGHT_FIXTURES' | 'SURFACE_EFFECTS' | 'DRIFT_LIGHT' | 'PHYSICAL_SPECULAR' | 'SURFACE_OVERLAY' | 'REFLECTION_MAPS';
+export type LitSwitch = 'GLASS_SHADOWS' | 'CLUSTERED_LIGHTS' | 'LIGHT_FIXTURES' | 'SURFACE_EFFECTS' | 'DRIFT_LIGHT' | 'PHYSICAL_SPECULAR' | 'SURFACE_OVERLAY' | 'REFLECTION_MAPS' | 'WORLD_UVS' | 'MOVING_SUN' | 'LAYERED';
 /** Every switch off: what a renderer starts from before its profile and its content say otherwise. */
 export declare function noLitSwitches(): Record<LitSwitch, boolean>;
 /** Which of the lit stage's optional features a build reads. See `litSwitchesGlsl`. */

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

@@ -34,6 +34,9 @@ export function noLitSwitches() {
         PHYSICAL_SPECULAR: false,
         SURFACE_OVERLAY: false,
         REFLECTION_MAPS: false,
+        WORLD_UVS: false,
+        MOVING_SUN: false,
+        LAYERED: false,
     };
 }
 /**

package/dist/render/shaders/flat/index.d.ts

@@ -125,6 +125,21 @@ export interface FlatShaderOptions {
      * the frame's materials' reflections. True when absent. See `reflectionSurfaceGlsl`.
      */
     readonly reflectionMaps?: boolean;
+    /**
+     * Whether it places a material's maps by the world, `uWorldUv` and all (`SurfaceMaterial
+     * .projection`). True when absent. See `worldUvGlsl`.
+     */
+    readonly worldUvs?: boolean;
+    /**
+     * Whether it reads the sun's moving layer through a matrix of its own, \`uMovingLightViewProj\`
+     * and all. True when absent. See \`movingSunGlsl\`.
+     */
+    readonly movingSun?: boolean;
+    /**
+     * Whether it blends a material's layers by a mask, \`uLayers\` and all (\`SurfaceMaterial.layers\`).
+     * True when absent. See \`layeredGlsl\`.
+     */
+    readonly layered?: boolean;
     /**
      * How many point lights this build declares room for. `MAX_POINT_LIGHTS` when absent.
      *

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

@@ -18,9 +18,14 @@ import { modelsGlsl } from './models.js';
 import { AREA_LIGHT_GLSL } from './areaLight.js';
 import { NORMAL_MAP_GLSL } from './normalMap.js';
 import { DRIFT_LIGHT_GLSL } from './driftLight.js';
+import { LIGHTMAP_OPACITY_STEPS } from '../../instances.js';
 import { SURFACE_EFFECTS_GLSL } from './surfaceEffects.js';
 import { overlayGlsl } from './overlay.js';
 import { reflectionSurfaceGlsl } from './reflectionSurface.js';
+import { worldUvGlsl } from './worldUv.js';
+import { movingSunGlsl } from './movingSun.js';
+import { layeredGlsl } from './layered.js';
+import { MAP_READS_GLSL } from './mapReads.js';
 import { CHANNEL_BEND, LIT_CHANNEL_ATTRIBUTE } from '../vertexChannel.js';
 import { BONE_ANIMATION_GLSL } from '../boneAnimation.js';
 import { FULL_LIGHT_BUDGET } from '../../uniformVectorBudget.js';
@@ -337,10 +342,16 @@ void main() {
   vAlpha = aInstanceTint.w;
   vThickness = 1.0;
   if (LIGHTMAP_REGIONS) {
+    /*
+     * The opacity's transparency rides the U offset as whole steps of 2, the offset itself under 1
+     * (\`MeshInstances.lightmapRegions\`): taken off, and none where the instance is opaque.
+     */
+    float steps = floor(aInstanceTint.z * 0.5);
+    float offsetU = aInstanceTint.z - 2.0 * steps;
     /* Out of the lane's \`-1 - uv\`, through the region, and back into it. See lightmap.ts. */
-    vGrain = -1.0 - ((-1.0 - aGrain) * aInstanceTint.x + aInstanceTint.z);
+    vGrain = -1.0 - ((-1.0 - aGrain) * aInstanceTint.x + offsetU);
     vRelief = -1.0 - ((-1.0 - aRelief) * aInstanceTint.y + aInstanceTint.w);
-    vAlpha = 1.0;
+    vAlpha = 1.0 - steps / ${LIGHTMAP_OPACITY_STEPS.toFixed(1)};
   }
 #else
   vSkyDirect = aChannel.y;
@@ -461,6 +472,8 @@ export function flatFrag(options) {
             surfaceEffects: options.surfaceEffects ?? true,
             driftLight: options.driftLight ?? true,
         }),
+        /* Depth zero and ahead of the sun's lookup, which calls it; its switch takes the next id. */
+        movingSunGlsl(options.movingSun ?? true),
         LOBES_GLSL,
         POINTSHADOW_GLSL,
         DIRECTIONALSHADOW_GLSL,
@@ -486,8 +499,6 @@ export function flatFrag(options) {
          * and `main` is unconditional by construction.
          */
         TANGENT_FRAME_GLSL,
-        /* After the frame it calls, unconditional for the same reason. See normalMap.ts. */
-        NORMAL_MAP_GLSL,
         /* Unconditional for the same reason, and called only where a cutoff was asked for. */
         CUTOUT_COVERAGE_GLSL,
         CUTOUT_DITHER_GLSL,
@@ -499,6 +510,15 @@ export function flatFrag(options) {
         overlayGlsl(options.surfaceOverlay ?? true),
         /* After the overlay, so its switch takes the next id. See reflectionSurface.ts. */
         reflectionSurfaceGlsl(options.reflectionMaps ?? true),
+        /* After the reflection maps, so its switch takes the next id; main calls it. worldUv.ts. */
+        worldUvGlsl(options.worldUvs ?? true),
+        /* After the projection, so its switch takes the next id; the normal map below calls it. */
+        layeredGlsl(options.layered ?? true),
+        /* Where each map is read, after both of the ways it can be read otherwise. See mapReads.ts. */
+        MAP_READS_GLSL,
+        /* After the frame and the projection it calls, unconditional for the same reason as the
+           frame. See normalMap.ts. */
+        NORMAL_MAP_GLSL,
         /* After the models, whose answer to a rectangle it asks for. See areaLight.ts. */
         AREA_LIGHT_GLSL,
         MAIN_GLSL,

package/dist/render/shaders/flat/layered.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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
+ * 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,
+ * or from the vertex colour; an added mask placed as the layers are raises one layer's weight, and
+ * one layer may be weighed by how much the surface faces up instead of by its channel.
+ *
+ * **Two ways to combine them.** Laid over, each layer covers everything before it, so a layer's
+ * share is its weight times one less each later weight, and the base keeps what none took. Summed,
+ * the base is mixed toward each layer times its weight by the weights' sum held to 1, so each
+ * layer's share is its weight times that and the base keeps the rest. The shares are worked out once
+ * a pixel, in `layeredBegin`; colour, roughness and occlusion are blended by them, and the normal
+ * map's tangent-space texels too, before the frame turns them into the world — around a normal read
+ * at the mesh's own coordinates, where the material lays one under the layers.
+ *
+ * **Every layer present is read, whatever its share.** A read whose level is implicit is legal only
+ * 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.
+ */
+export declare function layeredGlsl(on: boolean): string;

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

@@ -0,0 +1,198 @@
+/**
+ * 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
+ * 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,
+ * or from the vertex colour; an added mask placed as the layers are raises one layer's weight, and
+ * one layer may be weighed by how much the surface faces up instead of by its channel.
+ *
+ * **Two ways to combine them.** Laid over, each layer covers everything before it, so a layer's
+ * share is its weight times one less each later weight, and the base keeps what none took. Summed,
+ * the base is mixed toward each layer times its weight by the weights' sum held to 1, so each
+ * layer's share is its weight times that and the base keeps the rest. The shares are worked out once
+ * a pixel, in `layeredBegin`; colour, roughness and occlusion are blended by them, and the normal
+ * map's tangent-space texels too, before the frame turns them into the world — around a normal read
+ * at the mesh's own coordinates, where the material lays one under the layers.
+ *
+ * **Every layer present is read, whatever its share.** A read whose level is implicit is legal only
+ * 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.
+ */
+export function layeredGlsl(on) {
+    if (!on) {
+        return /* glsl */ `
+const bool LAYERED = false;  // wgsl:override
+bool layered() { return false; }
+void layeredBegin() {}
+vec3 layeredColor(vec3 color) { return color; }
+vec4 layeredAlbedo() { return vec4(1.0); }
+vec3 layeredOrm() { return vec3(1.0); }
+vec3 layeredTexel() { return vec3(0.0, 0.0, 1.0); }
+bool layeredMeshNormal() { return false; }
+vec3 layeredMeshTexel() { return vec3(0.0, 0.0, 1.0); }
+bool layeredGlows() { return false; }
+vec3 layeredEmissive() { return vec3(0.0); }
+`;
+    }
+    return /* glsl */ `
+/* Whether this program blends a material's layers. Off but where one has asked: layered.ts. */
+const bool LAYERED = true;  // wgsl:override
+/*
+ * Four vectors, as surfaceLayers.ts packs them: the five repeats, base first (x y z w, then x); the
+ * count (y), the glowing layer or -1 (z) and where the mask is, 0 a map, 1 the ORM array, 2 the
+ * vertex colour (w); the blend, 0 over and 1 summed (x), whether a mesh normal is laid under the
+ * layers (y), the added mask's layer or -1 (z) and its repeat (w); its intensity (x), the facing
+ * layer or -1 (y), its bias (z) and its sharpness (w).
+ */
+uniform vec4 uLayers[4]; // wgsl:material
+
+/* 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;
+
+bool layered() {
+  return uLayers[1].y > 0.5;
+}
+
+float layerRepeat(int i) {
+  return i < 4 ? uLayers[0][i] : uLayers[1].x;
+}
+
+/* Where the layers are laid: the world's horizontal plane under a projection, the mesh's otherwise. */
+vec2 layerPlace() {
+  if (WORLD_UVS && projected()) return planarAt();
+  return vUv.xy;
+}
+
+vec3 layerAt(int i) {
+  return vec3(layerPlace() * layerRepeat(i), float(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));
+  return texture(uModelMap, vec3(vUv.xy, 0.0));
+}
+
+/* Which of layers 1 to 4 a packed layer number names, as a vector of one 1: none for -1. */
+vec4 layerPick(float layer) {
+  return vec4(equal(vec4(layer), vec4(1.0, 2.0, 3.0, 4.0)));
+}
+
+/*
+ * The weights, changed where the material asks and zero past the count, and every share from them.
+ * Under a branch on uniforms, as its reads are.
+ */
+void layeredBegin() {
+  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 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));
+  }
+  if (uLayers[3].y > 0.5) {
+    float up = normalize(vNormal).y * 0.5 + 0.5;
+    float facing = clamp(uLayers[3].z + uLayers[3].w * up, 0.0, 1.0);
+    m = mix(m, vec4(facing), layerPick(uLayers[3].y));
+  }
+  float n = uLayers[1].y;
+  m *= vec4(n > 1.5 ? 1.0 : 0.0, n > 2.5 ? 1.0 : 0.0, n > 3.5 ? 1.0 : 0.0, n > 4.5 ? 1.0 : 0.0);
+  if (uLayers[2].x > 0.5) {
+    float taken = min(m.x + m.y + m.z + m.w, 1.0);
+    lShare = m * taken;
+    lShareBase = 1.0 - taken;
+    return;
+  }
+  /* Each over everything before it: a layer keeps its weight of what every later one leaves. */
+  float keep = 1.0;
+  lShare.w = m.w * keep;
+  keep *= 1.0 - m.w;
+  lShare.z = m.z * keep;
+  keep *= 1.0 - m.z;
+  lShare.y = m.y * keep;
+  keep *= 1.0 - m.y;
+  lShare.x = m.x * keep;
+  keep *= 1.0 - m.x;
+  lShareBase = keep;
+}
+
+float layerShare(int i) {
+  if (i == 0) return lShareBase;
+  return lShare[i - 1];
+}
+
+/* The vertex colour's part in the albedo: none where it is the mask instead. */
+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. */
+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);
+    if (i == 0) sum.a = t.a;
+  }
+  return sum;
+}
+
+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);
+  }
+  return sum;
+}
+
+/* A tangent-space texel off the normal array, its z rebuilt where a two-channel map stored none. */
+vec3 layerNormalTexel(vec3 at) {
+  vec3 t = texture(uNormalMap, at).xyz * 2.0 - 1.0;
+  t.z = t.z > 0.0 ? t.z : sqrt(max(0.0, 1.0 - dot(t.xy, t.xy)));
+  return t;
+}
+
+/* The tangent-space texels blended by the shares. */
+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);
+  }
+  float len = length(sum);
+  return len > 1e-5 ? sum / len : vec3(0.0, 0.0, 1.0);
+}
+
+/* Whether a normal read at the mesh's own coordinates lies under the layers. */
+bool layeredMeshNormal() {
+  return uLayers[2].y > 0.5;
+}
+
+/* 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));
+}
+
+/* Whether the emissive map belongs to one layer rather than to the whole surface. */
+bool layeredGlows() {
+  return uLayers[1].z > -0.5;
+}
+
+/* The emissive map at its layer's place, glowing by that layer's share. */
+vec3 layeredEmissive() {
+  int glow = int(uLayers[1].z + 0.5);
+  return texture(uEmissiveMap, layerAt(glow)).rgb * layerShare(glow);
+}
+`;
+}