@driftengine/core 4.4.2 → 4.5.0

package/dist/render/renderQuality.js

@@ -56,6 +56,7 @@ export const DEFAULT_RENDER_QUALITY = Object.freeze({
     shadowFilterTaps: MAX_SHADOW_FILTER_TAPS,
     lightVolumeSamples: 32,
     directionalShadowDepthLayers: 2,
+    glassShadows: 'full',
     directionalShadowMaxDistance: 6,
     directionalShadowMaxSlope: 3,
     pointShadowRebakeDistance: 0.001,
@@ -205,6 +206,7 @@ export function resolveRenderQuality(options = {}) {
         shadowFilterTaps: options.shadowFilterTaps ?? DEFAULT_RENDER_QUALITY.shadowFilterTaps,
         lightVolumeSamples: options.lightVolumeSamples ?? DEFAULT_RENDER_QUALITY.lightVolumeSamples,
         directionalShadowDepthLayers: options.directionalShadowDepthLayers ?? DEFAULT_RENDER_QUALITY.directionalShadowDepthLayers,
+        glassShadows: options.glassShadows ?? DEFAULT_RENDER_QUALITY.glassShadows,
         directionalShadowMaxDistance: options.directionalShadowMaxDistance ?? DEFAULT_RENDER_QUALITY.directionalShadowMaxDistance,
         directionalShadowMaxSlope: options.directionalShadowMaxSlope ?? DEFAULT_RENDER_QUALITY.directionalShadowMaxSlope,
         pointShadowRebakeDistance: options.pointShadowRebakeDistance ?? DEFAULT_RENDER_QUALITY.pointShadowRebakeDistance,
@@ -286,6 +288,11 @@ export function resolveRenderQuality(options = {}) {
     if (quality.directionalShadowDepthLayers !== 1 && quality.directionalShadowDepthLayers !== 2) {
         throw new Error(`RenderQuality.directionalShadowDepthLayers must be 1 or 2, got ${quality.directionalShadowDepthLayers}`);
     }
+    if (quality.glassShadows !== 'full' &&
+        quality.glassShadows !== 'half' &&
+        quality.glassShadows !== 'off') {
+        throw new Error(`RenderQuality.glassShadows must be 'full', 'half' or 'off', got ${String(quality.glassShadows)}`);
+    }
     if (quality.plumeNoiseOctaves > 3) {
         throw new Error(`RenderQuality.plumeNoiseOctaves must be <= 3, got ${quality.plumeNoiseOctaves}`);
     }

package/dist/render/rendererHarness.js

@@ -86,6 +86,18 @@ export function recordingGl(options = {}) {
         COLOR_BUFFER_BIT: 0x00004000,
         /* Named so a test can tell a mesh that declared itself deforming from one that did not. */
         ARRAY_BUFFER: 0x8892,
+        /* Named so a blend a pass sets can be read back as numbers: glass multiplies what it lets
+           through, and a test that cannot tell DST_COLOR from a recorder cannot tell it multiplies. */
+        ZERO: 0,
+        DST_ALPHA: 0x0304,
+        DST_COLOR: 0x0306,
+        FUNC_ADD: 0x8006,
+        COLOR: 0x1800,
+        DEPTH: 0x1801,
+        /* Named so a copy can be read as from-and-to: a blit's two framebuffers are the whole claim. */
+        READ_FRAMEBUFFER: 0x8ca8,
+        DRAW_FRAMEBUFFER: 0x8ca9,
+        BLEND: 0x0be2,
         STATIC_DRAW: 0x88e4,
         DYNAMIC_DRAW: 0x88e8,
     };

package/dist/render/sceneTarget.d.ts

@@ -72,6 +72,8 @@ export declare class SceneTarget {
     private colorCopyFramebuffer;
     /** Whether this frame has filled it. One snapshot serves every refracting draw in a frame. */
     private colorCopyFilled;
+    /** Whether this frame's copy has its mip chain, which frosted glass reads. See `snapshotColor`. */
+    private colorCopyMips;
     /**
      * The colour grade, as a 3D texture on unit 4, and the table it was built from.
      *
@@ -221,7 +223,11 @@ export declare class SceneTarget {
      * Null where the copy could not be made, and a caller must read that as "do not refract" rather
      * than as a black texture — refracting against black paints every pane the colour of a hole.
      */
-    snapshotColor(afresh?: boolean): WebGLTexture | null;
+    snapshotColor(afresh?: boolean, 
+    /** Fill the copy's mip chain as well, once a frame: what frosted glass reads. */
+    mips?: boolean): WebGLTexture | null;
+    /** The copy's mip chain from its level 0, once per copy. */
+    private fillColorCopyMips;
     snapshotDepth(
     /**
      * Take the copy again even though one has already been taken this frame.

package/dist/render/sceneTarget.js

@@ -76,6 +76,8 @@ export class SceneTarget {
     colorCopyFramebuffer = null;
     /** Whether this frame has filled it. One snapshot serves every refracting draw in a frame. */
     colorCopyFilled = false;
+    /** Whether this frame's copy has its mip chain, which frosted glass reads. See `snapshotColor`. */
+    colorCopyMips = false;
     /**
      * The colour grade, as a 3D texture on unit 4, and the table it was built from.
      *
@@ -241,13 +243,25 @@ export class SceneTarget {
         if (this.colorCopy === null)
             this.colorCopy = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, this.colorCopy);
-        if (this.floatColor) {
-            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, width, height, 0, gl.RGBA, gl.HALF_FLOAT, null);
-        }
-        else {
-            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        /*
+         * **Every level, so glass can read a blurrier one.** Frosted glass reads the copy at a level its
+         * frost picks, and a texture sampled through a mipmapping filter with a level missing is
+         * incomplete and reads black — so the chain is allocated here, once per size, and filled only on
+         * a frame that draws glass (`snapshotColor`). Plain refraction reads level 0, as it always has.
+         */
+        const levels = Math.floor(Math.log2(Math.max(width, height))) + 1;
+        for (let level = 0; level < levels; level += 1) {
+            const w = Math.max(1, width >> level);
+            const h = Math.max(1, height >> level);
+            if (this.floatColor) {
+                gl.texImage2D(gl.TEXTURE_2D, level, gl.RGBA16F, w, h, 0, gl.RGBA, gl.HALF_FLOAT, null);
+            }
+            else {
+                gl.texImage2D(gl.TEXTURE_2D, level, gl.RGBA, w, h, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+            }
         }
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAX_LEVEL, levels - 1);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
@@ -359,6 +373,7 @@ export class SceneTarget {
         /* Last frame's snapshot is last frame's scene. See `snapshotDepth`. */
         this.depthCopyFilled = false;
         this.colorCopyFilled = false;
+        this.colorCopyMips = false;
         this.bind();
     }
     /**
@@ -449,15 +464,22 @@ export class SceneTarget {
      * Null where the copy could not be made, and a caller must read that as "do not refract" rather
      * than as a black texture — refracting against black paints every pane the colour of a hole.
      */
-    snapshotColor(afresh = false) {
+    snapshotColor(afresh = false, 
+    /** Fill the copy's mip chain as well, once a frame: what frosted glass reads. */
+    mips = false) {
         if (this.colorCopy === null || this.colorCopyFramebuffer === null)
             return null;
-        if (this.colorCopyFilled && !afresh)
+        if (this.colorCopyFilled && !afresh) {
+            if (mips)
+                this.fillColorCopyMips();
             return this.colorCopy;
+        }
         const { gl } = this;
         const source = this.msaaFramebuffer ?? this.framebuffer;
         if (source === null)
             return null;
+        const drawing = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+        const reading = gl.getParameter(gl.READ_FRAMEBUFFER_BINDING);
         gl.bindFramebuffer(gl.READ_FRAMEBUFFER, source);
         gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this.colorCopyFramebuffer);
         /* Drained first, for the reason `resolve` gives at length: `getError` reports whatever is
@@ -470,13 +492,34 @@ export class SceneTarget {
            choice only decides which refusals are possible. */
         gl.blitFramebuffer(0, 0, this.width, this.height, 0, 0, this.width, this.height, gl.COLOR_BUFFER_BIT, gl.NEAREST);
         const refused = gl.getError() !== gl.NO_ERROR;
-        /* Back to what the caller was drawing into, whichever that was. */
-        gl.bindFramebuffer(gl.FRAMEBUFFER, source);
+        /*
+         * **Back to what the caller was drawing into, whichever that was** — read before the copy and
+         * handed back, never assumed. It was the scene's framebuffer, assumed, and a pane drawn into a
+         * reflection probe's face then left the scene's bound: the probe attached its next face to it,
+         * a face-sized colour beside a screen-sized depth, and every draw after refused as incomplete.
+         */
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, drawing);
+        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, reading);
         if (refused)
             return null;
         this.colorCopyFilled = true;
+        this.colorCopyMips = false;
+        if (mips)
+            this.fillColorCopyMips();
         return this.colorCopy;
     }
+    /** The copy's mip chain from its level 0, once per copy. */
+    fillColorCopyMips() {
+        if (this.colorCopyMips || this.colorCopy === null)
+            return;
+        const { gl } = this;
+        /* Bound on whichever unit is active and handed back, so the caller's texture there survives. */
+        const previous = gl.getParameter(gl.TEXTURE_BINDING_2D);
+        gl.bindTexture(gl.TEXTURE_2D, this.colorCopy);
+        gl.generateMipmap(gl.TEXTURE_2D);
+        gl.bindTexture(gl.TEXTURE_2D, previous);
+        this.colorCopyMips = true;
+    }
     snapshotDepth(
     /**
      * Take the copy again even though one has already been taken this frame.
@@ -499,6 +542,8 @@ export class SceneTarget {
         const source = this.msaaFramebuffer ?? this.framebuffer;
         if (source === null)
             return null;
+        const drawing = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+        const reading = gl.getParameter(gl.READ_FRAMEBUFFER_BINDING);
         gl.bindFramebuffer(gl.READ_FRAMEBUFFER, source);
         gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this.depthCopyFramebuffer);
         /* Drained first, for the reason `resolve` gives at length: `getError` reports whatever is
@@ -509,8 +554,9 @@ export class SceneTarget {
         }
         gl.blitFramebuffer(0, 0, this.width, this.height, 0, 0, this.width, this.height, gl.DEPTH_BUFFER_BIT, gl.NEAREST);
         const refused = gl.getError() !== gl.NO_ERROR;
-        /* Back to what the caller was drawing into, whichever that was. */
-        gl.bindFramebuffer(gl.FRAMEBUFFER, source);
+        /* Back to what the caller was drawing into, read rather than assumed: see `snapshotColor`. */
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, drawing);
+        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, reading);
         if (refused)
             return null;
         this.depthCopyFilled = true;

package/dist/render/shaders/depth.d.ts

@@ -23,7 +23,7 @@ export declare const DEPTH_INSTANCED_VERT: string;
  */
 export declare const DEPTH_CUTOUT_VERT: string;
 export declare const DEPTH_INSTANCED_CUTOUT_VERT: string;
-export declare const DEPTH_FRAG = "#version 300 es\nprecision highp float;\nin vec4 vLightPosition;\n\nuniform highp sampler2D uPreviousShadowMap;\nuniform int uPeelShadowLayer;\n\nvoid main() {\n  if (uPeelShadowLayer != 0) {\n    vec3 p = vLightPosition.xyz / vLightPosition.w;\n    vec2 uv = p.xy * 0.5 + 0.5;\n    float previousDepth = texture(uPreviousShadowMap, uv).r;\n    // Discard the already-recorded surface and everything in front of it. The\n    // ordinary depth test then stores the next independently fading occluder.\n    if (gl_FragCoord.z <= previousDepth + 0.00001) discard;\n  }\n}\n";
+export declare const DEPTH_FRAG = "#version 300 es\nprecision highp float;\nin vec4 vLightPosition;\n\nuniform highp sampler2DArray uPreviousShadowMap;\nuniform int uPeelShadowLayer;\n\nvoid main() {\n  if (uPeelShadowLayer != 0) {\n    vec3 p = vLightPosition.xyz / vLightPosition.w;\n    vec2 uv = p.xy * 0.5 + 0.5;\n    float previousDepth = texture(uPreviousShadowMap, vec3(uv, 0.0)).r;\n    // Discard the already-recorded surface and everything in front of it. The\n    // ordinary depth test then stores the next independently fading occluder.\n    if (gl_FragCoord.z <= previousDepth + 0.00001) discard;\n  }\n}\n";
 /**
  * The cutout caster's depth: the plain pass, and a texel of alpha under the cutoff writes nothing.
  *
@@ -37,3 +37,18 @@ export declare const DEPTH_FRAG = "#version 300 es\nprecision highp float;\nin v
  * map takes the next.
  */
 export declare const DEPTH_CUTOUT_FRAG: string;
+/**
+ * The glass tint's vertex stages: every way a caster is drawn, with the world position handed on.
+ *
+ * **The same five as the depth pass, and for the same reason**: a pane must cast its colour from
+ * exactly where it casts its depth, deformed and placed the same way, or the coloured patch parts
+ * from the pane's own shadow edge. The only addition is `vGlassWorld`.
+ */
+export declare const GLASS_TINT_VERT: string;
+export declare const GLASS_TINT_SKINNED_VERT: string;
+export declare const GLASS_TINT_INSTANCED_VERT: string;
+export declare const GLASS_TINT_CUTOUT_VERT: string;
+export declare const GLASS_TINT_INSTANCED_CUTOUT_VERT: string;
+export declare const GLASS_TINT_FRAG = "#version 300 es\nprecision highp float;\nin vec4 vLightPosition;\nin vec3 vGlassWorld;\n\n/* rgb: transmission times tint; a: clarity, one less the frost. */\nuniform vec4 uGlassPane;\n/* xyz: the light's position (w 1) or the direction toward it (w 0). */\nuniform vec4 uGlassLight;\n\nout vec4 outTint;\n\nvoid main() {\n\n  vec3 n = normalize(cross(dFdx(vGlassWorld), dFdy(vGlassWorld)));\n  vec3 toLight = uGlassLight.w > 0.5 ? normalize(uGlassLight.xyz - vGlassWorld) : uGlassLight.xyz;\n  float cosLight = abs(dot(n, toLight));\n  float reflected = 0.04 + 0.96 * pow(1.0 - cosLight, 5.0);\n  outTint = vec4(uGlassPane.rgb * (1.0 - reflected), uGlassPane.a);\n\n}\n";
+/** A cut-out pane: its colour lands only where its depth does, by the depth cutout's own test. */
+export declare const GLASS_TINT_CUTOUT_FRAG: string;

package/dist/render/shaders/depth.js

@@ -1,4 +1,5 @@
 import { resolveConditionals } from './conditionals.js';
+import { SUN_STATIC_LAYER } from '../shadowMap.js';
 import { CUTOUT_COVERAGE_GLSL } from './cutoutCoverage.js';
 import { SKINNING_GLSL } from './skinning.js';
 import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from './vertexChannel.js';
@@ -72,6 +73,11 @@ out vec4 vLightPosition;
 out vec2 vUv;
 flat out float vAlphaCutout;
 #endif
+#if GLASS
+/* Where on the pane this is, for the tint's own normal and its angle to the light. Last, so the
+   outputs before it keep the locations the plain variants give them. */
+out vec3 vGlassWorld;
+#endif
 
 void main() {
 #if SKINNED
@@ -99,12 +105,15 @@ void main() {
   vUv = aUv * uUvScale;
   vAlphaCutout = uAlphaCutout;
 #endif
+#if GLASS
+  vGlassWorld = bent;
+#endif
 }
 `;
 /** The rigid variant: the world, a prop, a mesh with no rig behind it. */
-export const DEPTH_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: false }, 'depth');
+export const DEPTH_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: false, GLASS: false }, 'depth');
 /** The skinned variant, which reads a joint palette and moves the vertex by it. */
-export const DEPTH_SKINNED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: true, INSTANCED: false, CUTOUT: false }, 'depth-skinned');
+export const DEPTH_SKINNED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: true, INSTANCED: false, CUTOUT: false, GLASS: false }, 'depth-skinned');
 /**
  * The variant an instanced draw casts its shadow through.
  *
@@ -113,7 +122,7 @@ export const DEPTH_SKINNED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINN
  * right place and the rest stacked underneath it, which reads as a lighting fault rather than as
  * a missing variant, and is the shape the per-draw ring exists to prevent one level up.
  */
-export const DEPTH_INSTANCED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: false }, 'depth-instanced');
+export const DEPTH_INSTANCED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: false, GLASS: false }, 'depth-instanced');
 /**
  * The variants a cutout caster casts through: a leaf card, a chain link, a fence, whose shape is in
  * its texture's alpha rather than in its geometry.
@@ -124,20 +133,20 @@ export const DEPTH_INSTANCED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKI
  * leaves every opaque caster byte for byte as it was. What it costs is one more program each, and
  * a skinned cutout, which nothing has asked for, is not among them.
  */
-export const DEPTH_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: true }, 'depth-cutout');
-export const DEPTH_INSTANCED_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: true }, 'depth-instanced-cutout');
+export const DEPTH_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: true, GLASS: false }, 'depth-cutout');
+export const DEPTH_INSTANCED_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: true, GLASS: false }, 'depth-instanced-cutout');
 export const DEPTH_FRAG = `#version 300 es
 precision highp float;
 in vec4 vLightPosition;
 
-uniform highp sampler2D uPreviousShadowMap;
+uniform highp sampler2DArray uPreviousShadowMap;
 uniform int uPeelShadowLayer;
 
 void main() {
   if (uPeelShadowLayer != 0) {
     vec3 p = vLightPosition.xyz / vLightPosition.w;
     vec2 uv = p.xy * 0.5 + 0.5;
-    float previousDepth = texture(uPreviousShadowMap, uv).r;
+    float previousDepth = texture(uPreviousShadowMap, vec3(uv, ${SUN_STATIC_LAYER}.0)).r;
     // Discard the already-recorded surface and everything in front of it. The
     // ordinary depth test then stores the next independently fading occluder.
     if (gl_FragCoord.z <= previousDepth + 0.00001) discard;
@@ -162,7 +171,7 @@ in vec4 vLightPosition;
 in vec2 vUv;
 flat in float vAlphaCutout;
 
-uniform highp sampler2D uPreviousShadowMap;
+uniform highp sampler2DArray uPreviousShadowMap;
 uniform int uPeelShadowLayer;
 uniform highp sampler2D uCutoutMap;
 ${CUTOUT_COVERAGE_GLSL}
@@ -172,9 +181,76 @@ void main() {
   if (uPeelShadowLayer != 0) {
     vec3 p = vLightPosition.xyz / vLightPosition.w;
     vec2 uv = p.xy * 0.5 + 0.5;
-    float previousDepth = textureLod(uPreviousShadowMap, uv, 0.0).r;
+    float previousDepth = textureLod(uPreviousShadowMap, vec3(uv, ${SUN_STATIC_LAYER}.0), 0.0).r;
     if (gl_FragCoord.z <= previousDepth + 0.00001) discard;
   }
   if (alpha < vAlphaCutout) discard;
 }
 `;
+/**
+ * The glass tint's vertex stages: every way a caster is drawn, with the world position handed on.
+ *
+ * **The same five as the depth pass, and for the same reason**: a pane must cast its colour from
+ * exactly where it casts its depth, deformed and placed the same way, or the coloured patch parts
+ * from the pane's own shadow edge. The only addition is `vGlassWorld`.
+ */
+export const GLASS_TINT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: false, GLASS: true }, 'glass-tint');
+export const GLASS_TINT_SKINNED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: true, INSTANCED: false, CUTOUT: false, GLASS: true }, 'glass-tint-skinned');
+export const GLASS_TINT_INSTANCED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: false, GLASS: true }, 'glass-tint-instanced');
+export const GLASS_TINT_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: true, GLASS: true }, 'glass-tint-cutout');
+export const GLASS_TINT_INSTANCED_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: true, GLASS: true }, 'glass-tint-instanced-cutout');
+/**
+ * What a pane lets through: its transmission and colour, less what it reflects toward the light,
+ * and how clear it is — `glassShadow.ts`'s `paneTexel`, stated for the device. Drawn with a
+ * multiplying blend and no depth test, so every pane on a ray contributes whatever order they
+ * come in.
+ *
+ * **The pane's normal is its triangle's**, from the derivatives of its world position, first and in
+ * uniform control flow: a pane is flat, a sign does not matter to a cosine taken absolutely, and it
+ * spares the five vertex stages a normal they would carry for this alone. What it gives up is a
+ * curved pane, whose Fresnel steps per triangle; what would change it is glass that is mostly bulbs.
+ */
+const GLASS_TINT_BODY = /* glsl */ `
+  vec3 n = normalize(cross(dFdx(vGlassWorld), dFdy(vGlassWorld)));
+  vec3 toLight = uGlassLight.w > 0.5 ? normalize(uGlassLight.xyz - vGlassWorld) : uGlassLight.xyz;
+  float cosLight = abs(dot(n, toLight));
+  float reflected = 0.04 + 0.96 * pow(1.0 - cosLight, 5.0);
+  outTint = vec4(uGlassPane.rgb * (1.0 - reflected), uGlassPane.a);
+`;
+export const GLASS_TINT_FRAG = `#version 300 es
+precision highp float;
+in vec4 vLightPosition;
+in vec3 vGlassWorld;
+
+/* rgb: transmission times tint; a: clarity, one less the frost. */
+uniform vec4 uGlassPane;
+/* xyz: the light's position (w 1) or the direction toward it (w 0). */
+uniform vec4 uGlassLight;
+
+out vec4 outTint;
+
+void main() {
+${GLASS_TINT_BODY}
+}
+`;
+/** A cut-out pane: its colour lands only where its depth does, by the depth cutout's own test. */
+export const GLASS_TINT_CUTOUT_FRAG = `#version 300 es
+precision highp float;
+in vec4 vLightPosition;
+in vec2 vUv;
+flat in float vAlphaCutout;
+in vec3 vGlassWorld;
+
+uniform vec4 uGlassPane;
+uniform vec4 uGlassLight;
+uniform highp sampler2D uCutoutMap;
+${CUTOUT_COVERAGE_GLSL}
+out vec4 outTint;
+
+void main() {
+  /* First, in uniform control flow, as the depth cutout samples it. */
+  float alpha = cutoutAlpha(texture(uCutoutMap, vUv).a, vUv * vec2(textureSize(uCutoutMap, 0)));
+${GLASS_TINT_BODY}
+  if (alpha < vAlphaCutout) discard;
+}
+`;

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

@@ -1,5 +1,7 @@
 /** Filtering the directional cascade, with receiver-plane depth gradient compensation. */
 import { DIRECTIONAL_SHADOW_FADE_START, MAX_SHADOW_FILTER_TAPS } from '../../renderQuality.js';
+import { SUN_DYNAMIC_LAYER, SUN_GLASS_MOVING_LAYER, SUN_GLASS_STATIC_LAYER, SUN_PEELED_LAYER, SUN_STATIC_LAYER, } from '../../shadowMap.js';
+import { FROST_RADIUS_CAP, FROST_SPREAD } from '../../glassShadow.js';
 export const DIRECTIONALSHADOW_GLSL = `vec2 receiverPlaneDepthGradient(vec3 p) {
   vec3 dx = dFdx(p);
   vec3 dy = dFdy(p);
@@ -126,10 +128,10 @@ float shadowFactor(float directionalNdl) {
    */
   float coarseCompare = p.z - 1.0 / uShadowDepthSpan;
   float coarse =
-    directionalVisibility(p.z, coarseCompare, textureLod(uStaticShadowMap, p.xy, 0.0).r) *
-    directionalVisibility(p.z, coarseCompare, textureLod(uDynamicShadowMap, p.xy, 0.0).r);
+    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);
   if (uPeeledShadowEnabled != 0) {
-    coarse *= directionalVisibility(p.z, coarseCompare, textureLod(uPeeledShadowMap, p.xy, 0.0).r);
+    coarse *= directionalVisibility(p.z, coarseCompare, textureLod(uSunShadows, vec3(p.xy, ${SUN_PEELED_LAYER}.0), 0.0).r);
   }
   float strength = uShadowStrength * edgeFade * lowElevationFade;
   if (receiverFade <= 0.0) return mix(1.0, coarse, strength);
@@ -190,11 +192,11 @@ float shadowFactor(float directionalNdl) {
      * \`shadowMap.ts\` allocates these with one storage level and \`NEAREST\` filtering, so
      * there is no mip to select and level zero is the only thing \`texture\` could have read.
      */
-    float staticDepth = textureLod(uStaticShadowMap, sampleUv, 0.0).r;
-    float dynamicDepth = textureLod(uDynamicShadowMap, sampleUv, 0.0).r;
+    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(uPeeledShadowMap, sampleUv, 0.0).r;
+      float peeledDepth = textureLod(uSunShadows, vec3(sampleUv, ${SUN_PEELED_LAYER}.0), 0.0).r;
       peeledLit += directionalVisibility(tapReceiverDepth, compare, peeledDepth);
     } else {
       peeledLit += 1.0;
@@ -214,6 +216,89 @@ float shadowFactor(float directionalNdl) {
 
   return mix(1.0, mix(coarse, lit, receiverFade), strength);
 }
+
+/*
+ * One of the sun's two glass layers at receiver p: how milky the nearest pane is and how far behind
+ * it this receiver stands, the spread that follows (glassShadow.ts's frostRadius, capped), and the
+ * tint's level for that spread. Then glassShadow.ts's spreadTint: the outline from taps at the base
+ * radius — where the clear pane's patch ends — and the colour from the spread taps, each read coarse,
+ * unmixed from the ground around it and weighed by the pane's share of it, so a frosted patch mixes
+ * its panes' colours and keeps the light the clear one lets through. What it gives up is a pane lying
+ * 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) {
+  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;
+  float radius = clamp(
+    (1.0 - clarity) * ${FROST_SPREAD.toFixed(6)} * behind * uvPerMetre,
+    texel,
+    texel * ${FROST_RADIUS_CAP.toFixed(1)}
+  );
+  float lod = log2(max(radius * tintSize, 1.0));
+  float cover = 0.0;
+  vec3 colour = vec3(0.0);
+  float found = 0.0;
+  for (int i = 0; i < ${MAX_SHADOW_FILTER_TAPS}; i++) {
+    if (i >= uShadowFilterTaps) break;
+    vec2 offset = DIRECTIONAL_PCF_OFFSETS[i];
+    vec2 edgeUv = p.xy + offset * texel;
+    cover += p.z > textureLod(uSunShadows, vec3(edgeUv, paneLayer), 0.0).r + bias ? 1.0 : 0.0;
+    /* The spread taps weigh by the pane's unmixed share rather than a depth test: continuous, so a
+       colour crossing between two panes blends rather than stepping through sixteen bands. */
+    vec4 pane = glassUnmix(textureLod(uSunGlassTints, vec3(p.xy + offset * radius, tintLayer), lod), clarity);
+    colour += pane.rgb * pane.a;
+    found += pane.a;
+  }
+  float taps = float(max(uShadowFilterTaps, 1));
+  return mix(vec3(1.0), found > 0.0 ? colour / found : vec3(1.0), cover / taps);
+}
+
+/*
+ * What the sun's light keeps of itself through glass at this receiver: glassShadow.ts's tap rule
+ * and frost spread, over shadowFactor's own taps. A tap counts a pane only when the receiver is
+ * farther from the sun than that pane (the glass depth layers), so a surface on the sun's side of a
+ * pane, and the pane itself, keep the sun's own colour; the taps average with equal weight, so the
+ * spread moves light rather than losing it. Frost widens the taps by how far behind the nearest pane
+ * the receiver is, capped, with the tap count unchanged. What it gives up is spread past the edge of
+ * an opaque frame's shadow, which this lookup never sees. Faded with the opaque shadow's own fades.
+ */
+vec3 sunGlassLookup(float directionalNdl) {
+  vec3 p = vLightPos.xyz / vLightPos.w;
+  p = p * 0.5 + 0.5;
+  /* 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);
+  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);
+  vec2 fromCentre = abs(p.xy - 0.5) * 2.0;
+  float edgeFade = 1.0 - smoothstep(0.72, 0.98, max(fromCentre.x, fromCentre.y));
+  edgeFade *= 1.0 - smoothstep(0.90, 1.0, p.z);
+  float shadowSlope = length(uDirectionalDir.xz) / max(uDirectionalDir.y, 0.001);
+  float lowElevationFade = 1.0 - smoothstep(
+    uShadowMaxSlope * ${DIRECTIONAL_SHADOW_FADE_START.toFixed(2)},
+    uShadowMaxSlope,
+    shadowSlope
+  );
+  float strength = uShadowStrength * edgeFade * lowElevationFade;
+  if (strength <= 0.0) return vec3(1.0);
+
+  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);
+  return mix(vec3(1.0), staticTint * movingTint, strength);
+}
+
+/* The way in, asking first whether this build reads glass at all (GLASS_SHADOWS). A constant, so
+   the lookup's derivatives are still taken in uniform control flow. */
+vec3 sunGlassTint(float directionalNdl) {
+  if (GLASS_SHADOWS) return sunGlassLookup(directionalNdl);
+  return vec3(1.0);
+}
 #endif
 
 /**

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

@@ -0,0 +1,6 @@
+/**
+ * What the lit stage shares between every glass tint it reads: whether it reads any, and
+ * `glassShadow.ts`'s `unmixTint`, stated once for the sun's lookup and the lamps'. At depth zero,
+ * outside every conditional, so each lookup can call it whichever shadows a permutation compiles.
+ */
+export declare function glassTintGlsl(glassShadows: boolean): string;

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

@@ -0,0 +1,25 @@
+/**
+ * What the lit stage shares between every glass tint it reads: whether it reads any, and
+ * `glassShadow.ts`'s `unmixTint`, stated once for the sun's lookup and the lamps'. At depth zero,
+ * outside every conditional, so each lookup can call it whichever shadows a permutation compiles.
+ */
+export function glassTintGlsl(glassShadows) {
+    return /* glsl */ `
+/*
+ * Whether this build reads glass at all, which every way into the lookups asks first — and as a
+ * branch's own condition, never negated: see \`overridableConstants\` in scripts/wgsl/transform.mjs.
+ */
+const bool GLASS_SHADOWS = ${glassShadows ? 'true' : 'false'};  // wgsl:override
+/*
+ * A coarse level of a glass tint with the open ground's white taken back out, by how milky the pane
+ * at the centre is: rgb the pane's colour, a its share of the texel (glassShadow.ts's unmixTint).
+ * A clear centre is never read coarse, so it is returned as it stands.
+ */
+vec4 glassUnmix(vec4 mip, float centreClarity) {
+  if (centreClarity >= 1.0) return vec4(mip.rgb, 1.0);
+  float share = clamp((1.0 - mip.a) / (1.0 - centreClarity), 0.0, 1.0);
+  if (share <= 0.0) return vec4(1.0, 1.0, 1.0, 0.0);
+  return vec4(clamp((mip.rgb - vec3(1.0 - share)) / share, 0.0, 1.0), share);
+}
+`;
+}

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

@@ -79,6 +79,19 @@ export interface FlatShaderOptions {
      * for its instructions not to be there.
      */
     readonly nightEmissive: boolean;
+    /**
+     * Whether this build reads glass in its shadows at all: `glassShadows` other than `'off'`. True
+     * when absent, which is what the generated WGSL is built with.
+     *
+     * **Not a permutation axis, and the payload is why.** Every lit permutation carries the glass
+     * lookups, and a second copy of each without them would be most of the generated file again. So
+     * it is one switch, `GLASS_SHADOWS`, that every way into the lookups branches on first: written
+     * into this source for WebGL2, and a pipeline-overridable constant on the generated WGSL, which
+     * the device compiles away as it would under `#if`. That matters because the lookups returning
+     * at their first line still cost the lit pass its registers — 0.42 ms at 720p on WebGL2 on the
+     * courtyard at night, measured, and nothing once compiled out.
+     */
+    readonly glassShadows?: boolean;
     /**
      * How many point lights this build declares room for. `MAX_POINT_LIGHTS` when absent.
      *

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

@@ -7,6 +7,7 @@ import { preambleGlsl } from './preamble.js';
 import { LOBES_GLSL } from './lobes.js';
 import { POINTSHADOW_GLSL } from './pointShadow.js';
 import { DIRECTIONALSHADOW_GLSL } from './directionalShadow.js';
+import { glassTintGlsl } from './glassTint.js';
 import { MORPH_GLSL } from '../morph.js';
 import { SKINNING_GLSL } from '../skinning.js';
 import { SURFACE_GLSL } from './surface.js';
@@ -354,6 +355,9 @@ export function flatFrag(options) {
          * is at depth zero, and it is still declared before `pointShadow` uses it.
          */
         OCTAHEDRAL_GLSL,
+        /* Depth zero as well: both glass lookups, sun and lamps, call it, and every permutation
+           declares its switch, which the pipelines set whether the permutation reads it or not. */
+        glassTintGlsl(options.glassShadows ?? true),
         LOBES_GLSL,
         POINTSHADOW_GLSL,
         DIRECTIONALSHADOW_GLSL,

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

@@ -0,0 +1 @@
+export declare const LAMP_GLASS_GLSL: string;