@driftengine/core 4.13.6 → 4.14.0

package/src/render/shaders/flat/iridescentOverlay.ts

@@ -0,0 +1,65 @@
+/**
+ * A surface's iridescent overlay on its base colour, before it is lit:
+ * `SurfaceMaterial.iridescentOverlay`, packed into `uIridescence` by `iridescentOverlay.ts`, whose
+ * `iridescentBase` is this arithmetic on the CPU and says what each term is and what it gives up.
+ *
+ * **Called once the normal is mapped and turned to the viewer**, so the view term reads the surface
+ * a pixel shows, and before any light is added, so the lights below read the colour it makes. The
+ * mask is read in uniform control flow, under the lighting branch and this switch's, so its implicit
+ * level is legal: AGENTS.md 2026-08-07.
+ *
+ * **A lit switch, `IRIDESCENT_OVERLAY`**, off until a material first asks, declared after
+ * `EMISSIVE_FLOW` so each switch before it keeps its id. Compiled out, its thirty-six vectors are
+ * not declared and the call is a constant.
+ */
+export function iridescentOverlayGlsl(on: boolean): string {
+  if (!on) {
+    return /* glsl */ `
+const bool IRIDESCENT_OVERLAY = false;  // wgsl:override
+bool iridescent() { return false; }
+vec3 iridescentBase(vec3 base, vec3 n, vec2 uv) { return base; }
+`;
+  }
+  return /* glsl */ `
+/* Whether this program lays an iridescent overlay. Off but where a material has asked. */
+const bool IRIDESCENT_OVERLAY = true;  // wgsl:override
+/*
+ * Thirty-six vectors, as iridescentOverlay.ts packs them: the direction toward the sheen and the
+ * blend (0); the contrast, the tiling, the weight and 1 for on (1); the mask's array, 0 none, 1 ORM,
+ * 2 model, 3 albedo, 4 emissive, its layer and its channel (2); what takes the material's
+ * coordinates back to the mesh's own (3); then the ramp, thirty-two colours.
+ */
+uniform vec4 uIridescence[36]; // wgsl:material
+
+bool iridescent() { return uIridescence[1].w > 0.5; }
+
+/* The mask's channel at the material's coordinates; 1 where it names no array. */
+float iridescentMask(vec2 uv) {
+  float source = uIridescence[2].x;
+  if (source < 0.5) return 1.0;
+  vec3 at = vec3(uv, uIridescence[2].y);
+  vec4 texel = source < 1.5 ? texture(uOrmMap, at)
+    : source < 2.5 ? texture(uModelMap, at)
+    : source < 3.5 ? texture(uAlbedo, at)
+    : texture(uEmissiveMap, at);
+  return texel[int(uIridescence[2].z + 0.5)];
+}
+
+vec3 iridescentBase(vec3 base, vec3 n, vec2 uv) {
+  vec3 toEye = normalize(uCameraPos - vWorldPos);
+  vec3 halfway = toEye + uIridescence[0].xyz;
+  float span = length(halfway);
+  float nh = span > 0.0 ? dot(n, halfway / span) : 0.0;
+  float sheen = nh > 0.0 ? clamp(pow(nh, uIridescence[1].x), 0.0, 1.0) : 0.0;
+  float nv = dot(n, toEye);
+  vec2 own = vUv.xy * uIridescence[3].xy + uIridescence[3].zw;
+  float x = nv + own.x + uIridescence[0].w * (sheen - nv);
+  float t = clamp(fract(x * uIridescence[1].y), 0.0, 1.0);
+  float at = t * 31.0;
+  int below = min(int(floor(at)), 30);
+  vec3 o = mix(uIridescence[4 + below].rgb, uIridescence[5 + below].rgb, at - float(below));
+  vec3 blended = mix(2.0 * base * o, 1.0 - 2.0 * (1.0 - base) * (1.0 - o), step(0.5, base));
+  return base + (blended - base) * (x * iridescentMask(uv) * uIridescence[1].z);
+}
+`;
+}

package/src/render/shaders/flat/layered.ts

@@ -41,7 +41,7 @@ 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); }
+vec3 layeredEmissive(vec2 shift) { return vec3(0.0); }
 float layeredAmbient() { return 1.0; }
 float layeredSpecular(float own) { return own; }
 `;
@@ -254,10 +254,10 @@ bool layeredGlows() {
   return uLayers[1].z > -0.5;
 }
 
-/* The emissive map at its layer's place, glowing by that layer's share. */
-vec3 layeredEmissive() {
+/* The emissive map at its layer's place, moved by its scroll, glowing by that layer's share. */
+vec3 layeredEmissive(vec2 shift) {
   int glow = int(uLayers[1].z + 0.5);
-  return texture(uEmissiveMap, layerAt(glow)).rgb * layerShare(glow);
+  return texture(uEmissiveMap, layerAt(glow) + vec3(shift, 0.0)).rgb * layerShare(glow);
 }
 `;
 }

package/src/render/shaders/flat/main.ts

@@ -399,6 +399,8 @@ export const MAIN_GLSL = `void main() {
     if (backFace) n = -n;
     /* A blending rim, on the base colour every light below reads: overlay.ts. */
     if (SURFACE_OVERLAY) albedo = overlayRimBase(albedo, surfaceAt.xy, n);
+    /* And a view-turned hue over it, before any light reads it: iridescentOverlay.ts. */
+    if (IRIDESCENT_OVERLAY && iridescent()) albedo = iridescentBase(albedo, n, surfaceAt.xy);
     /*
      * A model's surface, gathered once, on a branch on the switches alone (models.ts) — and whether
      * there is one, asked once: every site below is a branch on these two, which a pipeline with no
@@ -407,6 +409,13 @@ export const MAIN_GLSL = `void main() {
     bool modelled = modelOn();
     bool modelledBehind = modelSeesBehind();
     if (modelled) modelSurface(n, albedo, surfaceRoughness, metal, surfaceAt);
+    /*
+     * The frame's decals laid into the colour light falls on, by the geometric normal, after the
+     * model has made its own (baseDecals.ts). The colour a glow takes where the mesh names none is
+     * kept from before them: a decal marks what the surface is lit as and leaves what it emits.
+     */
+    vec3 glowBase = albedo;
+    if (BASE_DECALS) albedo = baseDecals(albedo, vWorldPos, normalize(vNormal));
     /*
      * Skin's colour half leaves here, with the colour its spread light is multiplied by, and a whole
      * alpha a multisampled edge resolves to its coverage. A branch on the switches alone, so uniform.
@@ -1988,7 +1997,7 @@ export const MAIN_GLSL = `void main() {
       lit += through * glassGlow * (thin * (1.0 - metal));
     }
     diffuseAlone = lit;
-    vec3 emissiveTint = vEmissiveColor.r < 0.0 ? albedo : vEmissiveColor;
+    vec3 emissiveTint = vEmissiveColor.r < 0.0 ? glowBase : vEmissiveColor;
     /*
      * Where the surface glows, from an image, or everywhere if it binds none.
      *
@@ -2008,6 +2017,8 @@ export const MAIN_GLSL = `void main() {
     vec3 emissiveMapped = vec3(1.0);
     if (uMaterialFlags.z != 0) {
       emissiveMapped = emissiveTexel(surfaceAt) * uEmissiveScale;
+      /* Held to where the mask keeps it, at the mesh's own coordinates: emissiveFlow.ts. */
+      if (EMISSIVE_FLOW) emissiveMapped *= emissiveMask();
     }
     /* Pulse, flicker and fade from the layer's effects; exactly 1 where it names none. */
     float fxGlow = fx4.z + fx5.x + fx5.w > 0.0 ? fxEmission(surfaceAt.z) : 1.0;

package/src/render/shaders/flat/mapReads.ts

@@ -30,9 +30,13 @@ vec3 ormTexel(vec3 at) {
   return texture(uOrmMap, at).rgb;
 }
 
+/* The emissive map, moved by its scroll wherever it is read: emissiveFlow.ts. Behind its switch,
+   which a WebGPU pipeline built before a material asked has off, so the mask and the scroll come
+   on together rather than the scroll a few frames ahead. */
 vec3 emissiveTexel(vec3 at) {
-  if (LAYERED && layered() && layeredGlows()) return layeredEmissive();
-  if (WORLD_UVS && triplanar()) return triplanarEmissive(at.z);
-  return texture(uEmissiveMap, at).rgb;
+  vec2 shift = EMISSIVE_FLOW ? emissiveShift() : vec2(0.0);
+  if (LAYERED && layered() && layeredGlows()) return layeredEmissive(shift);
+  if (WORLD_UVS && triplanar()) return triplanarEmissive(at.z, shift);
+  return texture(uEmissiveMap, vec3(at.xy + shift, at.z)).rgb;
 }
 `;

package/src/render/shaders/flat/worldUv.ts

@@ -28,7 +28,7 @@ bool triplanar() { return false; }
 vec2 planarAt() { return vec2(0.0); }
 vec4 triplanarAlbedo(float layer) { return vec4(0.0); }
 vec3 triplanarOrm(float layer) { return vec3(0.0); }
-vec3 triplanarEmissive(float layer) { return vec3(0.0); }
+vec3 triplanarEmissive(float layer, vec2 shift) { return vec3(0.0); }
 vec3 triplanarNormal(vec3 n, float layer) { return n; }
 `;
   }
@@ -76,12 +76,13 @@ vec3 triplanarOrm(float layer) {
     texture(uOrmMap, vec3(p.xz, layer)).rgb * w.y + texture(uOrmMap, vec3(p.xy, layer)).rgb * w.z;
 }
 
-vec3 triplanarEmissive(float layer) {
+/* The emissive map on the three planes, each moved by the scroll: emissiveFlow.ts. */
+vec3 triplanarEmissive(float layer, vec2 shift) {
   vec3 w = triplanarWeights();
   vec3 p = vWorldPos * uWorldUv.y;
-  return texture(uEmissiveMap, vec3(p.zy, layer)).rgb * w.x +
-    texture(uEmissiveMap, vec3(p.xz, layer)).rgb * w.y +
-    texture(uEmissiveMap, vec3(p.xy, layer)).rgb * w.z;
+  return texture(uEmissiveMap, vec3(p.zy + shift, layer)).rgb * w.x +
+    texture(uEmissiveMap, vec3(p.xz + shift, layer)).rgb * w.y +
+    texture(uEmissiveMap, vec3(p.xy + shift, layer)).rgb * w.z;
 }
 
 /* A tangent-space normal off the map, its z rebuilt where a two-channel map stored none. */