@driftengine/core 4.13.5 → 4.14.0

package/dist/render/pointSkin.js

@@ -1,9 +1,23 @@
 import { MAX_JOINTS } from './skinPalette.js';
 /** Refuse a skin whose arrays disagree with a mesh of `vertices`, or that names a joint past the rest. */
 export function validatePointSkin(data, vertices) {
-    const fail = (what) => {
-        throw new Error(`point skin: ${what}`);
-    };
+    checkArrays(data, vertices, 'the mesh has');
+    checkJoints(data, 0);
+}
+/**
+ * Refuse a rewrite of vertices `first` onward, as many as `data` holds, that does not fit a mesh of
+ * `vertices`: arrays that disagree with each other, a range that is not whole vertices inside the
+ * mesh, or a joint past the rest. Named by the mesh's own vertex numbers.
+ */
+export function validatePointSkinRange(data, first, vertices) {
+    const count = data.weights.length / 4;
+    checkArrays(data, count, 'the weights hold');
+    if (!(Number.isInteger(first) && first >= 0 && first + count <= vertices)) {
+        throw new Error(`point skin: a rewrite of ${count} vertices from vertex ${first} for a mesh of ${vertices}`);
+    }
+    checkJoints(data, first);
+}
+function checkArrays(data, vertices, against) {
     for (const [name, values, width] of [
         ['joints', data.joints, 4],
         ['weights', data.weights, 4],
@@ -11,13 +25,17 @@ export function validatePointSkin(data, vertices) {
         ['normals', data.normals, 3],
     ]) {
         if (values.length !== vertices * width) {
-            fail(`${name} holds ${values.length / width} vertices and the mesh has ${vertices}`);
+            throw new Error(`point skin: ${name} holds ${values.length / width} vertices and ${against} ${vertices}`);
         }
     }
+}
+/** Every joint a whole number below `MAX_JOINTS`; a vertex named as `first` plus its place. */
+function checkJoints(data, first) {
     for (let at = 0; at < data.joints.length; at++) {
         const joint = data.joints[at];
         if (!(Number.isInteger(joint) && joint >= 0 && joint < MAX_JOINTS)) {
-            fail(`vertex ${Math.floor(at / 4)} names joint ${joint}; a joint is 0 to ${MAX_JOINTS - 1}`);
+            throw new Error(`point skin: vertex ${first + Math.floor(at / 4)} names joint ${joint}; a joint is 0 to ` +
+                `${MAX_JOINTS - 1}`);
         }
     }
 }
@@ -54,6 +72,33 @@ export function reachOf(data) {
         sums: vertices === 0 ? [1, 1] : [least, most],
     };
 }
+/**
+ * A skin's reach after part of it is rewritten with `data`: the farther of the old reach and the
+ * new at each joint, the joints the two name between them, and the widest span of weight sums.
+ *
+ * **It widens and never narrows**, because the vertices the rewrite replaced may have been the
+ * ones that set a joint's reach, and finding out would mean keeping every vertex on the CPU and
+ * reading them all again. A skin that changes shape back and forth settles at the union of its
+ * shapes, which is still a box no posed vertex leaves, and culls a little less than it could. What
+ * would make that wrong is a skin rewritten into ever larger shapes and never back; making it
+ * again with `createPointSkin` measures it afresh.
+ */
+export function widenReach(reach, data) {
+    const added = reachOf(data);
+    const joints = Math.max(reach.joints, added.joints);
+    const widened = new Float32Array(joints).fill(-1);
+    for (let j = 0; j < joints; j++) {
+        widened[j] = Math.max(j < reach.joints ? reach.reach[j] : -1, j < added.joints ? added.reach[j] : -1);
+    }
+    const vertices = data.weights.length / 4;
+    return {
+        joints,
+        reach: widened,
+        sums: vertices === 0
+            ? reach.sums
+            : [Math.min(reach.sums[0], added.sums[0]), Math.max(reach.sums[1], added.sums[1])],
+    };
+}
 /**
  * The bounds of a pose, into the mesh's own: `matrices` holds each joint's transform into the
  * mesh's model space, sixteen floats, column-major. Allocates nothing.

package/dist/render/recon/mover.d.ts

@@ -8,8 +8,9 @@
  * draw, last frame's palette.
  *
  * **Plain data, advanced by the renderer.** No renderer is needed to make one, so a consumer holds
- * it beside the object it belongs to. Only a reconstructing WebGPU renderer reads or writes it; it
- * costs nothing anywhere else. The fields past `kind` are the renderer's and a caller leaves them
+ * it beside the object it belongs to. A reconstructing WebGPU renderer reads and writes it, and so
+ * does a WebGL2 one resolving temporally (`backend/webgl2/motionTarget.ts`); it costs nothing
+ * anywhere else. The fields past `kind` are the renderer's and a caller leaves them
  * alone.
  *
  * **What would make this wrong** is a consumer whose objects are rebuilt every frame with no state

package/dist/render/recon/mover.js

@@ -8,8 +8,9 @@
  * draw, last frame's palette.
  *
  * **Plain data, advanced by the renderer.** No renderer is needed to make one, so a consumer holds
- * it beside the object it belongs to. Only a reconstructing WebGPU renderer reads or writes it; it
- * costs nothing anywhere else. The fields past `kind` are the renderer's and a caller leaves them
+ * it beside the object it belongs to. A reconstructing WebGPU renderer reads and writes it, and so
+ * does a WebGL2 one resolving temporally (`backend/webgl2/motionTarget.ts`); it costs nothing
+ * anywhere else. The fields past `kind` are the renderer's and a caller leaves them
  * alone.
  *
  * **What would make this wrong** is a consumer whose objects are rebuilt every frame with no state

package/dist/render/sceneTarget.d.ts

@@ -341,6 +341,8 @@ export declare class SceneTarget {
         readonly blend: number;
         readonly periodStart: boolean;
         readonly depthToViewZ: Float32Array;
+        /** Where the frame's movers stood last frame, or absent for the camera's motion alone. */
+        readonly motion?: WebGLTexture | null;
     }): void;
     dispose(): void;
 }

package/dist/render/sceneTarget.js

@@ -789,7 +789,7 @@ export class SceneTarget {
         let scene = this.texture;
         if (temporal !== undefined && this.texture !== null && this.depth !== null) {
             this.temporal ??= new TemporalPass(gl, this.floatColor);
-            scene = this.temporal.temporalResolve(this.texture, this.depth, temporal.reprojection, this.width, this.height, temporal.blend, temporal.periodStart, temporal.depthToViewZ);
+            scene = this.temporal.temporalResolve(this.texture, this.depth, temporal.reprojection, this.width, this.height, temporal.blend, temporal.periodStart, temporal.depthToViewZ, temporal.motion ?? null);
         }
         let bloomTexture = null;
         if (bloom !== undefined && scene !== null) {

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

@@ -0,0 +1,17 @@
+/**
+ * Decals laid into a surface's base colour before it is lit: `setBaseDecals`, packed into
+ * `uBaseDecals` by `baseDecals.ts`, where what they are for and what they give up is said, and the
+ * material's own refusal in `uDecalReceiver` (`SurfaceMaterial.receivesDecals`).
+ *
+ * **Each decal is a test and a fetch**: the world point taken into the box by three rows, outside
+ * it or turned too far from the projection and nothing, else the image read across the box's face
+ * from its square in the fixture atlas, its colour decoded from sRGB and laid over the base colour
+ * by its alpha and the decal's opacity. The geometric normal decides the facing, so a normal map's
+ * bump does not cut a mark. The loop is over a count in a uniform and the fetch is `textureLod`, as
+ * every read of the atlas is, so neither needs uniform control flow: AGENTS.md 2026-08-07.
+ *
+ * **A lit switch, `BASE_DECALS`**, off until a frame first lays one, declared after
+ * `IRIDESCENT_OVERLAY` so each switch before it keeps its id. Compiled out, its thirty-four vectors
+ * are not declared and the call is a constant.
+ */
+export declare function baseDecalsGlsl(on: boolean): string;

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

@@ -0,0 +1,71 @@
+/**
+ * Decals laid into a surface's base colour before it is lit: `setBaseDecals`, packed into
+ * `uBaseDecals` by `baseDecals.ts`, where what they are for and what they give up is said, and the
+ * material's own refusal in `uDecalReceiver` (`SurfaceMaterial.receivesDecals`).
+ *
+ * **Each decal is a test and a fetch**: the world point taken into the box by three rows, outside
+ * it or turned too far from the projection and nothing, else the image read across the box's face
+ * from its square in the fixture atlas, its colour decoded from sRGB and laid over the base colour
+ * by its alpha and the decal's opacity. The geometric normal decides the facing, so a normal map's
+ * bump does not cut a mark. The loop is over a count in a uniform and the fetch is `textureLod`, as
+ * every read of the atlas is, so neither needs uniform control flow: AGENTS.md 2026-08-07.
+ *
+ * **A lit switch, `BASE_DECALS`**, off until a frame first lays one, declared after
+ * `IRIDESCENT_OVERLAY` so each switch before it keeps its id. Compiled out, its thirty-four vectors
+ * are not declared and the call is a constant.
+ */
+export function baseDecalsGlsl(on) {
+    if (!on) {
+        return /* glsl */ `
+const bool BASE_DECALS = false;  // wgsl:override
+vec3 baseDecals(vec3 base, vec3 world, vec3 geometric) { return base; }
+`;
+    }
+    return /* glsl */ `
+/* Whether this program lays decals into base colours. Off but where a frame has laid one. */
+const bool BASE_DECALS = true;  // wgsl:override
+/*
+ * A header, how many decals, the atlas row their band starts at and its squares' side (0); then
+ * four vectors a decal, eight decals: the three rows taking a world point into its box, x across,
+ * y up the image, z along the projection, and its image, opacity and facing cosine.
+ */
+uniform vec4 uBaseDecals[33]; // wgsl:material
+/* x 1 where the material refuses decals, so an unwritten zero receives them. */
+uniform vec4 uDecalReceiver; // wgsl:material
+
+vec3 decalLinear(vec3 c) {
+  return mix(c / 12.92, pow((c + 0.055) / 1.055, vec3(2.4)), step(0.04045, c));
+}
+
+vec3 baseDecals(vec3 base, vec3 world, vec3 geometric) {
+  if (uDecalReceiver.x > 0.5) return base;
+  int count = int(uBaseDecals[0].x + 0.5);
+  vec2 atlas = vec2(textureSize(uFixtureAtlas, 0));
+  float span = uBaseDecals[0].z;
+  /* Half a texel of a square, so a bilinear read at its edge cannot reach the next one. */
+  float inset = 0.5 / span;
+  for (int i = 0; i < 8; i++) {
+    if (i >= count) break;
+    vec4 across = uBaseDecals[1 + i * 4];
+    vec4 up = uBaseDecals[2 + i * 4];
+    vec4 along = uBaseDecals[3 + i * 4];
+    vec4 laid = uBaseDecals[4 + i * 4];
+    vec3 local = vec3(
+      dot(across.xyz, world) + across.w,
+      dot(up.xyz, world) + up.w,
+      dot(along.xyz, world) + along.w
+    );
+    if (any(greaterThan(abs(local), vec3(1.0)))) continue;
+    if (dot(geometric, -normalize(along.xyz)) < laid.z) continue;
+    vec2 face = vec2(local.x, -local.y) * 0.5 + 0.5;
+    vec2 at = vec2(
+      (laid.x + clamp(face.x, inset, 1.0 - inset)) * span / atlas.x,
+      (uBaseDecals[0].y + clamp(face.y, inset, 1.0 - inset) * span) / atlas.y
+    );
+    vec4 texel = textureLod(uFixtureAtlas, at, 0.0);
+    base = mix(base, decalLinear(texel.rgb), clamp(texel.a * laid.y, 0.0, 1.0));
+  }
+  return base;
+}
+`;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * A material's glow moved and masked: `SurfaceMaterial.emissiveScroll` and `emissiveMaskLayer`,
+ * packed into `uEmissiveFlow` by `emissiveFlow.ts`, where what each gives up is said.
+ *
+ * **The scroll** is added to wherever the emissive map is read, the mesh's coordinates, a layer's
+ * place or a projection's planes, as its own repeats a second times the surface clock, wrapped to
+ * one repeat. **The mask** is the alpha of a layer of the emissive map's own array at the mesh's
+ * first coordinates as they are: the vertex stage has already laid the material's repeat and offset
+ * on `vUv`, so the second vector holds their inverse, which gives the mesh's own back.
+ *
+ * **A lit switch, `EMISSIVE_FLOW`**, off until a material first asks, declared after
+ * `SURFACE_DETAIL` so each switch before it keeps its id. Compiled out, its two vectors are not
+ * declared and the shift and the mask are constants.
+ */
+export declare function emissiveFlowGlsl(on: boolean): string;

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

@@ -0,0 +1,45 @@
+/**
+ * A material's glow moved and masked: `SurfaceMaterial.emissiveScroll` and `emissiveMaskLayer`,
+ * packed into `uEmissiveFlow` by `emissiveFlow.ts`, where what each gives up is said.
+ *
+ * **The scroll** is added to wherever the emissive map is read, the mesh's coordinates, a layer's
+ * place or a projection's planes, as its own repeats a second times the surface clock, wrapped to
+ * one repeat. **The mask** is the alpha of a layer of the emissive map's own array at the mesh's
+ * first coordinates as they are: the vertex stage has already laid the material's repeat and offset
+ * on `vUv`, so the second vector holds their inverse, which gives the mesh's own back.
+ *
+ * **A lit switch, `EMISSIVE_FLOW`**, off until a material first asks, declared after
+ * `SURFACE_DETAIL` so each switch before it keeps its id. Compiled out, its two vectors are not
+ * declared and the shift and the mask are constants.
+ */
+export function emissiveFlowGlsl(on) {
+    if (!on) {
+        return /* glsl */ `
+const bool EMISSIVE_FLOW = false;  // wgsl:override
+vec2 emissiveShift() { return vec2(0.0); }
+float emissiveMask() { return 1.0; }
+`;
+    }
+    return /* glsl */ `
+/* Whether this program moves and masks a material's glow. Off but where one has asked. */
+const bool EMISSIVE_FLOW = true;  // wgsl:override
+/*
+ * Two vectors, as emissiveFlow.ts packs them: the scroll in repeats a second on u and v (x y) and
+ * the mask's layer of the emissive array plus one, 0 for none (z); then what takes the material's
+ * coordinates back to the mesh's own, a scale (x y) and an offset (z w).
+ */
+uniform vec4 uEmissiveFlow[2]; // wgsl:material
+
+/* The emissive map's coordinates moved by the clock, wrapped to one repeat for precision. */
+vec2 emissiveShift() {
+  return fract(uEmissiveFlow[0].xy * uSurfaceScene.x);
+}
+
+/* The mask's alpha at the mesh's own coordinates, under the branch on a bound emissive map. */
+float emissiveMask() {
+  if (uEmissiveFlow[0].z < 0.5) return 1.0;
+  vec2 own = vUv.xy * uEmissiveFlow[1].xy + uEmissiveFlow[1].zw;
+  return texture(uEmissiveMap, vec3(own, uEmissiveFlow[0].z - 1.0)).a;
+}
+`;
+}

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' | 'WORLD_UVS' | 'MOVING_SUN' | 'LAYERED' | 'LAYER_LOOKS' | 'SURFACE_DETAIL';
+export type LitSwitch = 'GLASS_SHADOWS' | 'CLUSTERED_LIGHTS' | 'LIGHT_FIXTURES' | 'SURFACE_EFFECTS' | 'DRIFT_LIGHT' | 'PHYSICAL_SPECULAR' | 'SURFACE_OVERLAY' | 'REFLECTION_MAPS' | 'WORLD_UVS' | 'MOVING_SUN' | 'LAYERED' | 'LAYER_LOOKS' | 'SURFACE_DETAIL' | 'EMISSIVE_FLOW' | 'IRIDESCENT_OVERLAY' | 'BASE_DECALS';
 /** 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

@@ -39,6 +39,9 @@ export function noLitSwitches() {
         LAYERED: false,
         LAYER_LOOKS: false,
         SURFACE_DETAIL: false,
+        EMISSIVE_FLOW: false,
+        IRIDESCENT_OVERLAY: false,
+        BASE_DECALS: false,
     };
 }
 /**

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

@@ -150,6 +150,22 @@ export interface FlatShaderOptions {
      * (\`SurfaceMaterial.detail\`). True when absent. See \`detailGlsl\`.
      */
     readonly surfaceDetail?: boolean;
+    /**
+     * Whether it moves and masks a material's glow, `uEmissiveFlow` and all
+     * (`SurfaceMaterial.emissiveScroll` and `emissiveMaskLayer`). True when absent. See
+     * `emissiveFlowGlsl`.
+     */
+    readonly emissiveFlow?: boolean;
+    /**
+     * Whether it lays a material's iridescent overlay on the base colour, `uIridescence` and all
+     * (`SurfaceMaterial.iridescentOverlay`). True when absent. See `iridescentOverlayGlsl`.
+     */
+    readonly iridescentOverlay?: boolean;
+    /**
+     * Whether it lays the frame's decals into base colours, `uBaseDecals` and all
+     * (`setBaseDecals`). True when absent. See `baseDecalsGlsl`.
+     */
+    readonly baseDecals?: boolean;
     /**
      * How many point lights this build declares room for. `MAX_POINT_LIGHTS` when absent.
      *

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

@@ -25,6 +25,9 @@ import { reflectionSurfaceGlsl } from './reflectionSurface.js';
 import { worldUvGlsl } from './worldUv.js';
 import { movingSunGlsl } from './movingSun.js';
 import { detailGlsl } from './detail.js';
+import { emissiveFlowGlsl } from './emissiveFlow.js';
+import { iridescentOverlayGlsl } from './iridescentOverlay.js';
+import { baseDecalsGlsl } from './baseDecals.js';
 import { layeredGlsl } from './layered.js';
 import { MAP_READS_GLSL } from './mapReads.js';
 import { CHANNEL_BEND, LIT_CHANNEL_ATTRIBUTE } from '../vertexChannel.js';
@@ -517,6 +520,12 @@ export function flatFrag(options) {
         layeredGlsl(options.layered ?? true, options.layerLooks ?? true),
         /* After the layers, so its switch takes the next id; main calls it. See detail.ts. */
         detailGlsl(options.surfaceDetail ?? true),
+        /* After the detail, so its switch takes the next id; the map reads call it. emissiveFlow.ts. */
+        emissiveFlowGlsl(options.emissiveFlow ?? true),
+        /* After the glow's flow, so its switch takes the next id; main calls it. iridescentOverlay.ts. */
+        iridescentOverlayGlsl(options.iridescentOverlay ?? true),
+        /* After the overlay, so its switch takes the next id; main calls it. baseDecals.ts. */
+        baseDecalsGlsl(options.baseDecals ?? 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

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

@@ -0,0 +1,15 @@
+/**
+ * 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 declare function iridescentOverlayGlsl(on: boolean): string;

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

@@ -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) {
+    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/dist/render/shaders/flat/layered.js

@@ -40,7 +40,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; }
 `;
@@ -253,10 +253,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);
 }
 `;
 }