@driftengine/core 4.4.2 → 4.6.0

package/src/render/shaders/generated/text.wgsl.ts

@@ -7,7 +7,7 @@
 
 export const TEXT_FRAG_WGSL = "struct Uniforms {\n    uColor: vec3<f32>,\n    uGlow: f32,\n    uAlpha: f32,\n}\n\nvar<private> vNormal_1: vec3<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vChar_1: f32;\nvar<private> fragColor: vec4<f32>;\nvar<private> vDepth_1: f32;\n\nfn main_1() {\n    var key: vec3<f32>;\n    var lambert: f32;\n    var lit: vec3<f32>;\n    var emissive: vec3<f32>;\n\n    key = vec3<f32>(-0.3549141f, 0.7098282f, 0.6084241f);\n    let _e19 = vNormal_1;\n    let _e21 = key;\n    lambert = (0.55f + (0.45f * max(dot(normalize(_e19), _e21), 0f)));\n    let _e27 = unnamed.uColor;\n    let _e28 = lambert;\n    lit = (_e27 * _e28);\n    let _e31 = unnamed.uColor;\n    let _e33 = unnamed.uGlow;\n    let _e35 = vChar_1;\n    emissive = ((_e31 * _e33) * (0.45f + (0.55f * _e35)));\n    let _e39 = lit;\n    let _e40 = emissive;\n    let _e41 = (_e39 + _e40);\n    let _e43 = unnamed.uAlpha;\n    fragColor = vec4<f32>(_e41.x, _e41.y, _e41.z, _e43);\n    return;\n}\n\n@fragment \nfn main(@location(0) vNormal: vec3<f32>, @location(2) vChar: f32, @location(1) vDepth: f32) -> @location(0) vec4<f32> {\n    vNormal_1 = vNormal;\n    vChar_1 = vChar;\n    vDepth_1 = vDepth;\n    main_1();\n    let _e7 = fragColor;\n    return _e7;\n}\n";
 
-export const TEXT_VERT_WGSL = "struct Uniforms {\n    uViewport: vec2<f32>,\n    uOrigin: vec2<f32>,\n    uCellSize: f32,\n    uDepth: f32,\n    uReveal: f32,\n    uCharCount: f32,\n    uCharOffset: f32,\n    uSpin: f32,\n    uPunch: f32,\n    uBob: f32,\n    uTime: f32,\n    uClipCorrection: mat4x4<f32>,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(0) member: vec3<f32>,\n    @location(1) member_1: f32,\n    @location(2) member_2: f32,\n}\n\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aCharIndex_1: f32;\nvar<private> aCorner_1: vec3<f32>;\nvar<private> aCell_1: vec2<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> aNormal_1: vec3<f32>;\nvar<private> vNormal: vec3<f32>;\nvar<private> vDepth: f32;\nvar<private> vChar: f32;\n\nfn rot_u0028_f1_u003b(a: ptr<function, f32>) -> mat2x2<f32> {\n    var s: f32;\n    var c: f32;\n\n    let _e40 = (*a);\n    s = sin(_e40);\n    let _e42 = (*a);\n    c = cos(_e42);\n    let _e44 = c;\n    let _e45 = s;\n    let _e47 = s;\n    let _e48 = c;\n    return mat2x2<f32>(vec2<f32>(_e44, -(_e45)), vec2<f32>(_e47, _e48));\n}\n\nfn settle_u0028_f1_u003b(t: ptr<function, f32>) -> f32 {\n    var d: f32;\n\n    let _e39 = (*t);\n    if (_e39 <= 0f) {\n        return 0f;\n    }\n    let _e41 = (*t);\n    if (_e41 >= 1f) {\n        return 1f;\n    }\n    let _e43 = (*t);\n    d = (1f - _e43);\n    let _e45 = d;\n    let _e46 = d;\n    let _e48 = (*t);\n    return (1f - ((_e45 * _e46) * cos((_e48 * 12f))));\n}\n\nfn main_1() {\n    var span: f32;\n    var start: f32;\n    var local: f32;\n    var eased: f32;\n    var param: f32;\n    var spin: f32;\n    var rise: f32;\n    var punch: f32;\n    var local3_: vec3<f32>;\n    var param_1: f32;\n    var cell: vec2<f32>;\n    var bob: f32;\n    var screen: vec2<f32>;\n    var view: vec3<f32>;\n    var invDepth: f32;\n    var ndc: vec2<f32>;\n    var depth: f32;\n    var n: vec3<f32>;\n    var param_2: f32;\n\n    let _e57 = unnamed.uCharCount;\n    span = max(_e57, 1f);\n    let _e59 = aCharIndex_1;\n    let _e61 = unnamed.uCharOffset;\n    let _e63 = span;\n    start = (((_e59 + _e61) / _e63) * 0.55f);\n    let _e67 = unnamed.uReveal;\n    let _e68 = start;\n    let _e70 = start;\n    local = clamp(((_e67 - _e68) / max(0.45f, (1f - _e70))), 0f, 1f);\n    let _e75 = local;\n    param = _e75;\n    let _e76 = settle_u0028_f1_u003b((&param));\n    eased = _e76;\n    let _e78 = unnamed.uSpin;\n    let _e79 = eased;\n    spin = (_e78 * (1f - _e79));\n    let _e82 = eased;\n    let _e85 = unnamed.uCellSize;\n    rise = (((1f - _e82) * _e85) * 6f);\n    let _e89 = unnamed.uPunch;\n    let _e90 = eased;\n    punch = (1f + (_e89 * (1f - abs(((_e90 * 2f) - 1f)))));\n    let _e97 = aCorner_1;\n    let _e99 = unnamed.uCellSize;\n    let _e102 = punch;\n    local3_ = (((_e97 * _e99) * 0.5f) * _e102);\n    let _e104 = spin;\n    param_1 = _e104;\n    let _e105 = rot_u0028_f1_u003b((&param_1));\n    let _e106 = local3_;\n    let _e108 = (_e105 * _e106.yz);\n    let _e109 = local3_;\n    local3_ = vec3<f32>(_e109.x, _e108.x, _e108.y);\n    let _e114 = aCell_1;\n    let _e116 = unnamed.uCellSize;\n    cell = (_e114 * _e116);\n    let _e119 = unnamed.uTime;\n    let _e121 = aCharIndex_1;\n    let _e126 = unnamed.uBob;\n    bob = (sin(((_e119 * 3.1f) + (_e121 * 0.7f))) * _e126);\n    let _e129 = unnamed.uOrigin;\n    let _e131 = cell[0u];\n    let _e133 = cell[1u];\n    let _e137 = rise;\n    let _e138 = bob;\n    screen = ((_e129 + vec2<f32>(_e131, -(_e133))) + vec2<f32>(0f, (_e137 - _e138)));\n    let _e142 = screen;\n    let _e143 = local3_;\n    let _e145 = (_e142 + _e143.xy);\n    let _e147 = unnamed.uDepth;\n    let _e150 = local3_[2u];\n    view = vec3<f32>(_e145.x, _e145.y, (-(_e147) + _e150));\n    let _e156 = unnamed.uDepth;\n    let _e158 = view[2u];\n    invDepth = (_e156 / max(0.001f, -(_e158)));\n    let _e162 = view;\n    let _e164 = invDepth;\n    let _e167 = unnamed.uViewport;\n    ndc = ((((_e162.xy * _e164) / _e167) * 2f) - vec2(1f));\n    let _e173 = local3_[2u];\n    let _e176 = unnamed.uCellSize;\n    depth = (clamp((-(_e173) / max(1f, (_e176 * 2f))), -1f, 1f) * 0.4f);\n    let _e183 = unnamed.uClipCorrection;\n    let _e185 = ndc[0u];\n    let _e187 = ndc[1u];\n    let _e189 = depth;\n    unnamed_1.gl_Position = (_e183 * vec4<f32>(_e185, -(_e187), _e189, 1f));\n    let _e193 = aNormal_1;\n    n = _e193;\n    let _e194 = spin;\n    param_2 = _e194;\n    let _e195 = rot_u0028_f1_u003b((&param_2));\n    let _e196 = n;\n    let _e198 = (_e195 * _e196.yz);\n    let _e199 = n;\n    n = vec3<f32>(_e199.x, _e198.x, _e198.y);\n    let _e204 = n;\n    vNormal = _e204;\n    let _e206 = local3_[2u];\n    vDepth = _e206;\n    let _e207 = eased;\n    vChar = _e207;\n    return;\n}\n\n@vertex \nfn main(@location(3) aCharIndex: f32, @location(0) aCorner: vec3<f32>, @location(2) aCell: vec2<f32>, @location(1) aNormal: vec3<f32>) -> VertexOutput {\n    aCharIndex_1 = aCharIndex;\n    aCorner_1 = aCorner;\n    aCell_1 = aCell;\n    aNormal_1 = aNormal;\n    main_1();\n    let _e14 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e14);\n    let _e16 = unnamed_1.gl_Position;\n    let _e17 = vNormal;\n    let _e18 = vDepth;\n    let _e19 = vChar;\n    return VertexOutput(_e16, _e17, _e18, _e19);\n}\n";
+export const TEXT_VERT_WGSL = "struct Uniforms {\n    uViewport: vec2<f32>,\n    uOrigin: vec2<f32>,\n    uCellSize: f32,\n    uDepth: f32,\n    uReveal: f32,\n    uCharCount: f32,\n    uCharOffset: f32,\n    uSpin: f32,\n    uPunch: f32,\n    uBob: f32,\n    uTime: f32,\n    uClipCorrection: mat4x4<f32>,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(0) member: vec3<f32>,\n    @location(1) member_1: f32,\n    @location(2) member_2: f32,\n}\n\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aCharIndex_1: f32;\nvar<private> aCorner_1: vec3<f32>;\nvar<private> aCell_1: vec2<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> aNormal_1: vec3<f32>;\nvar<private> vNormal: vec3<f32>;\nvar<private> vDepth: f32;\nvar<private> vChar: f32;\n\nfn rot_u0028_f1_u003b(a: ptr<function, f32>) -> mat2x2<f32> {\n    var s: f32;\n    var c: f32;\n\n    let _e40 = (*a);\n    s = sin(_e40);\n    let _e42 = (*a);\n    c = cos(_e42);\n    let _e44 = c;\n    let _e45 = s;\n    let _e47 = s;\n    let _e48 = c;\n    return mat2x2<f32>(vec2<f32>(_e44, -(_e45)), vec2<f32>(_e47, _e48));\n}\n\nfn settle_u0028_f1_u003b(t: ptr<function, f32>) -> f32 {\n    var d: f32;\n\n    let _e39 = (*t);\n    if (_e39 <= 0f) {\n        return 0f;\n    }\n    let _e41 = (*t);\n    if (_e41 >= 1f) {\n        return 1f;\n    }\n    let _e43 = (*t);\n    d = (1f - _e43);\n    let _e45 = d;\n    let _e46 = d;\n    let _e48 = (*t);\n    return (1f - ((_e45 * _e46) * cos((_e48 * 12f))));\n}\n\nfn main_1() {\n    var span: f32;\n    var start: f32;\n    var local: f32;\n    var eased: f32;\n    var param: f32;\n    var spin: f32;\n    var rise: f32;\n    var punch: f32;\n    var local3_: vec3<f32>;\n    var param_1: f32;\n    var cell: vec2<f32>;\n    var bob: f32;\n    var centre: vec2<f32>;\n    var invDepth: f32;\n    var screen: vec2<f32>;\n    var ndc: vec2<f32>;\n    var depth: f32;\n    var n: vec3<f32>;\n    var param_2: f32;\n\n    let _e57 = unnamed.uCharCount;\n    span = max(_e57, 1f);\n    let _e59 = aCharIndex_1;\n    let _e61 = unnamed.uCharOffset;\n    let _e63 = span;\n    start = (((_e59 + _e61) / _e63) * 0.55f);\n    let _e67 = unnamed.uReveal;\n    let _e68 = start;\n    let _e70 = start;\n    local = clamp(((_e67 - _e68) / max(0.45f, (1f - _e70))), 0f, 1f);\n    let _e75 = local;\n    param = _e75;\n    let _e76 = settle_u0028_f1_u003b((&param));\n    eased = _e76;\n    let _e78 = unnamed.uSpin;\n    let _e79 = eased;\n    spin = (_e78 * (1f - _e79));\n    let _e82 = eased;\n    let _e85 = unnamed.uCellSize;\n    rise = (((1f - _e82) * _e85) * 6f);\n    let _e89 = unnamed.uPunch;\n    let _e90 = eased;\n    punch = (1f + (_e89 * (1f - abs(((_e90 * 2f) - 1f)))));\n    let _e97 = aCorner_1;\n    let _e99 = unnamed.uCellSize;\n    let _e102 = punch;\n    local3_ = (((_e97 * _e99) * 0.5f) * _e102);\n    let _e104 = spin;\n    param_1 = _e104;\n    let _e105 = rot_u0028_f1_u003b((&param_1));\n    let _e106 = local3_;\n    let _e108 = (_e105 * _e106.yz);\n    let _e109 = local3_;\n    local3_ = vec3<f32>(_e109.x, _e108.x, _e108.y);\n    let _e114 = aCell_1;\n    let _e116 = unnamed.uCellSize;\n    cell = (_e114 * _e116);\n    let _e119 = unnamed.uTime;\n    let _e121 = aCharIndex_1;\n    let _e126 = unnamed.uBob;\n    bob = (sin(((_e119 * 3.1f) + (_e121 * 0.7f))) * _e126);\n    let _e129 = unnamed.uOrigin;\n    let _e131 = cell[0u];\n    let _e133 = cell[1u];\n    let _e137 = rise;\n    let _e138 = bob;\n    centre = ((_e129 + vec2<f32>(_e131, -(_e133))) + vec2<f32>(0f, (_e137 - _e138)));\n    let _e143 = unnamed.uDepth;\n    let _e145 = unnamed.uDepth;\n    let _e147 = local3_[2u];\n    invDepth = (_e143 / max(0.001f, (_e145 - _e147)));\n    let _e151 = centre;\n    let _e152 = local3_;\n    let _e154 = invDepth;\n    screen = (_e151 + (_e152.xy * _e154));\n    let _e157 = screen;\n    let _e159 = unnamed.uViewport;\n    ndc = (((_e157 / _e159) * 2f) - vec2(1f));\n    let _e165 = local3_[2u];\n    let _e168 = unnamed.uCellSize;\n    depth = (clamp((-(_e165) / max(1f, (_e168 * 2f))), -1f, 1f) * 0.4f);\n    let _e175 = unnamed.uClipCorrection;\n    let _e177 = ndc[0u];\n    let _e179 = ndc[1u];\n    let _e181 = depth;\n    unnamed_1.gl_Position = (_e175 * vec4<f32>(_e177, -(_e179), _e181, 1f));\n    let _e185 = aNormal_1;\n    n = _e185;\n    let _e186 = spin;\n    param_2 = _e186;\n    let _e187 = rot_u0028_f1_u003b((&param_2));\n    let _e188 = n;\n    let _e190 = (_e187 * _e188.yz);\n    let _e191 = n;\n    n = vec3<f32>(_e191.x, _e190.x, _e190.y);\n    let _e196 = n;\n    vNormal = _e196;\n    let _e198 = local3_[2u];\n    vDepth = _e198;\n    let _e199 = eased;\n    vChar = _e199;\n    return;\n}\n\n@vertex \nfn main(@location(3) aCharIndex: f32, @location(0) aCorner: vec3<f32>, @location(2) aCell: vec2<f32>, @location(1) aNormal: vec3<f32>) -> VertexOutput {\n    aCharIndex_1 = aCharIndex;\n    aCorner_1 = aCorner;\n    aCell_1 = aCell;\n    aNormal_1 = aNormal;\n    main_1();\n    let _e14 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e14);\n    let _e16 = unnamed_1.gl_Position;\n    let _e17 = vNormal;\n    let _e18 = vDepth;\n    let _e19 = vChar;\n    return VertexOutput(_e16, _e17, _e18, _e19);\n}\n";
 
 /**
  * What the transform assigned, so the renderer binds the same numbers.

package/src/render/shaders/gi/driftLight.wgsl.ts

@@ -14,8 +14,34 @@
  * filtering `driftSampler`; `origin` is the field's first sample and, in `w`, the spacing.
  */
 export const DRIFT_LIGHT_WGSL = /* wgsl */ `
+fn driftLightFacing(light: vec4<f32>, toward: vec4<f32>, n: vec3<f32>) -> vec3<f32> {
+  let arriving = light.rgb / light.a;
+  let towardLight = toward.xyz / light.a;
+  let facing = max(dot(n, towardLight), 0.0) + (1.0 - min(length(towardLight), 1.0)) * 0.25;
+  return arriving * facing;
+}
+
+fn driftLightDense(world: vec3<f32>, n: vec3<f32>, origin: vec4<f32>, spacing: f32) -> vec3<f32> {
+  let size = vec3<i32>(textureDimensions(driftAtlas, 0));
+  let dims = vec3<f32>(f32(size.x), f32(size.y / 2), f32(size.z));
+  let at = (world + n * (0.5 * spacing) - origin.xyz) / spacing;
+  if (any(at < vec3<f32>(0.0)) || any(at > dims - 1.0)) {
+    return vec3<f32>(0.0);
+  }
+  let uvw = (at + 0.5) / vec3<f32>(dims.x, dims.y * 2.0, dims.z);
+  let light = textureSampleLevel(driftAtlas, driftSampler, uvw, 0.0);
+  if (light.a < 1e-3) {
+    return vec3<f32>(0.0);
+  }
+  let toward = textureSampleLevel(driftAtlas, driftSampler, uvw + vec3<f32>(0.0, 0.5, 0.0), 0.0);
+  return driftLightFacing(light, toward, n);
+}
+
 fn driftLightIrradiance(world: vec3<f32>, n: vec3<f32>, origin: vec4<f32>) -> vec3<f32> {
   let spacing = origin.w;
+  if (spacing < 0.0) {
+    return driftLightDense(world, n, origin, -spacing);
+  }
   let at = (world + n * (0.5 * spacing) - origin.xyz) / (3.0 * spacing);
   let cell = vec3<i32>(floor(at));
   if (any(cell < vec3<i32>(0)) || any(cell >= vec3<i32>(textureDimensions(driftIndex, 0)))) {
@@ -41,9 +67,6 @@ fn driftLightIrradiance(world: vec3<f32>, n: vec3<f32>, origin: vec4<f32>) -> ve
     return vec3<f32>(0.0);
   }
   let toward = textureSampleLevel(driftAtlas, driftSampler, (corner + vec3<f32>(4.0, 0.0, 0.0) + inside) * texel, 0.0);
-  let arriving = light.rgb / light.a;
-  let towardLight = toward.xyz / light.a;
-  let facing = max(dot(n, towardLight), 0.0) + (1.0 - min(length(towardLight), 1.0)) * 0.25;
-  return arriving * facing;
+  return driftLightFacing(light, toward, n);
 }
 `;

package/src/render/shaders/globalMedium.ts

@@ -1,3 +1,4 @@
+import { SUN_DYNAMIC_LAYER, SUN_PEELED_LAYER, SUN_STATIC_LAYER } from '../shadowMap.ts';
 import { glslIsFarDepth, glslSceneDepthToNdc } from '../depthConvention.ts';
 import { MAX_GLOBAL_MEDIUM_STEPS } from '../globalMedium.ts';
 
@@ -79,9 +80,8 @@ uniform int uSteps;
 /** How much of the medium the sun's own shadow map removes, 0 to 1. At 0 nothing is sampled. */
 uniform float uSunShadow;
 uniform mat4 uLightViewProj;
-uniform sampler2D uStaticShadowMap;
-uniform sampler2D uPeeledShadowMap;
-uniform sampler2D uDynamicShadowMap;
+/* The sun's static, moving and peeled maps, as layers of one array: see shadowMap.ts. */
+uniform highp sampler2DArray uSunShadows;
 uniform int uPeeledShadowEnabled;
 
 out vec4 fragColor;
@@ -150,11 +150,11 @@ float sunReach(vec3 worldPos) {
   if (edgeFade <= 0.0) return 1.0;
 
   float compare = p.z - SHADOW_BIAS;
-  float blocked = occlusion(textureLod(uStaticShadowMap, p.xy, 0.0).r, compare);
+  float blocked = occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_STATIC_LAYER}.0), 0.0).r, compare);
   if (uPeeledShadowEnabled != 0) {
-    blocked = max(blocked, occlusion(textureLod(uPeeledShadowMap, p.xy, 0.0).r, compare));
+    blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_PEELED_LAYER}.0), 0.0).r, compare));
   }
-  blocked = max(blocked, occlusion(textureLod(uDynamicShadowMap, p.xy, 0.0).r, compare));
+  blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_DYNAMIC_LAYER}.0), 0.0).r, compare));
   return mix(1.0, 1.0 - blocked, uSunShadow * edgeFade);
 }
 

package/src/render/shaders/gpudriven/blendRaster.wgsl.ts

@@ -82,6 +82,28 @@ fn oitResolved(accum: vec4<f32>, reveal: f32) -> vec4<f32> {
 }
 `;
 
+/**
+ * Glass over its own shading, as the forward path draws it: `gpudriven/lit.ts`'s `glassShade`,
+ * which `scripts/gpu-parity.mjs` holds this to. Schlick at 0.04 with the angle unsigned — a pane
+ * passes the same light seen from either side — and floored at the forward path's grazing 0.05.
+ */
+const GLASS_SHADE_WGSL = /* wgsl */ `
+fn glassShade(
+  own: vec3<f32>,
+  seen: vec3<f32>,
+  transmission: f32,
+  frost: f32,
+  tint: vec3<f32>,
+  cosView: f32,
+  sunGlow: vec3<f32>,
+) -> vec3<f32> {
+  let c = clamp(abs(cosView), 0.05, 1.0);
+  let fresnel = 0.04 + 0.96 * pow(1.0 - c, 5.0);
+  let shown = transmission * (1.0 - fresnel);
+  return own + (seen * tint - own) * shown + sunGlow * tint * (frost * transmission);
+}
+`;
+
 export const BLEND_RASTER_WGSL = /* wgsl */ `
 struct BlendVarying {
   @builtin(position) position: vec4<f32>,
@@ -108,6 +130,12 @@ ${FRAME_BLOCK_WGSL}
 @group(0) @binding(9) var environmentMap: texture_2d_array<f32>;
 @group(0) @binding(10) var environmentSampler: sampler;
 ${decodeResourcesWgsl({ group: 0, latents: 11, clampSampler: 12, repeatSampler: 13, nodes: 14, weights: 15 })}
+/**
+ * What the opaque half drew, with a mip chain on a frame whose scene holds glass: a pane shows it,
+ * a frosted one a coarser level of it. Read only by a material whose transmission is not zero.
+ */
+@group(0) @binding(16) var opaqueColour: texture_2d<f32>;
+@group(0) @binding(17) var opaqueSampler: sampler;
 fn decodeLatentSize() -> f32 {
   return frame.size.w;
 }
@@ -126,6 +154,7 @@ ${MESH_TRANSFORM_WGSL}
 ${SHADE_LIGHTING_WGSL}
 ${FOG_WGSL}
 ${OIT_WGSL}
+${GLASS_SHADE_WGSL}
 
 const NO_PROGRAM_HERE: u32 = ${0xffffffff}u;
 
@@ -241,7 +270,25 @@ fn blendFrag(in: BlendVarying) -> BlendTargets {
    * distance — which is the whole reason this pipeline gained a fog.
    */
   let toward = distance(in.world, frame.eye.xyz);
-  let colour = mix(litColour(surface, room), mediumColour(), mediumFog(toward, in.world.y));
+  let fog = mediumFog(toward, in.world.y);
+  var colour = mix(litColour(surface, room), mediumColour(), fog);
+  /*
+   * **Glass shows what is behind it**, as the forward path's glass branch does: the opaque half's
+   * picture at this pixel, at the level frost picks, two short of the chain's end so a fully frosted
+   * pane keeps the large light and dark behind it. The sun glows through from the pane's far side,
+   * after the haze as the forward path adds it. A pane is seen from both sides, so its facing is
+   * the side toward the eye.
+   */
+  let transmission = entry.extra.y;
+  if (transmission > 0.0) {
+    let size = vec2<f32>(textureDimensions(opaqueColour, 0));
+    let levels = max(floor(log2(max(size.x, size.y))) - 2.0, 0.0);
+    let seen = textureSampleLevel(opaqueColour, opaqueSampler, in.position.xy / size, entry.extra.z * levels).xyz;
+    let cosView = dot(surface.normal, toEye);
+    let facing = select(surface.normal, -surface.normal, cosView < 0.0);
+    let sunGlow = frame.lightColour.xyz * max(-dot(facing, frame.lightDir.xyz), 0.0) * (1.0 - fog);
+    colour = glassShade(colour, seen, transmission, entry.extra.z, entry.glassTint.xyz, cosView, sunGlow);
+  }
 
   /*
    * **The distance to the eye, not the clip-space depth**, because that is what oitWeight's falloff
@@ -255,6 +302,20 @@ fn blendFrag(in: BlendVarying) -> BlendTargets {
   out.reveal = vec4<f32>(alpha, 0.0, 0.0, alpha);
   return out;
 }
+
+/*
+ * **What a pane lets through, drawn from the sun into the tint map**: \`blendVert\` again, handed
+ * the light's raster matrix and the glass list, and this for the colour — \`glassShadow.ts\`'s
+ * paneTexel, the forward path's GLASS_TINT_FRAG in this language. Written against a white target
+ * with a multiplying blend and no depth, so every pane on a ray counts in any order.
+ */
+@fragment
+fn glassTintFrag(in: BlendVarying) -> @location(0) vec4<f32> {
+  let entry = materials[min(in.material, ${MATERIAL_SLOTS - 1}u)];
+  let c = clamp(abs(dot(normalize(in.normal), frame.lightDir.xyz)), 0.05, 1.0);
+  let passes = entry.extra.y * (1.0 - (0.04 + 0.96 * pow(1.0 - c, 5.0)));
+  return vec4<f32>(passes * entry.glassTint.xyz, 1.0 - entry.extra.z);
+}
 `;
 
 /**
@@ -341,3 +402,29 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
   results[out + 3u] = resolved.z;
 }
 `;
+
+/**
+ * `glassShade` alone, as a dispatch, so it can be checked against `gpudriven/lit.ts`.
+ *
+ * Sixteen floats a case — own, seen, transmission, frost, tint, the view cosine, the glow, one
+ * spare — and four out, the colour and one spare.
+ */
+export const GLASS_SHADE_PARITY_WGSL = /* wgsl */ `
+@group(0) @binding(0) var<storage, read> cases: array<f32>;
+@group(0) @binding(1) var<storage, read_write> results: array<f32>;
+${GLASS_SHADE_WGSL}
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x * 16u + 15u >= arrayLength(&cases)) { return; }
+  let at = id.x * 16u;
+  let own = vec3<f32>(cases[at], cases[at + 1u], cases[at + 2u]);
+  let seen = vec3<f32>(cases[at + 3u], cases[at + 4u], cases[at + 5u]);
+  let tint = vec3<f32>(cases[at + 8u], cases[at + 9u], cases[at + 10u]);
+  let glow = vec3<f32>(cases[at + 12u], cases[at + 13u], cases[at + 14u]);
+  let shaded = glassShade(own, seen, cases[at + 6u], cases[at + 7u], tint, cases[at + 11u], glow);
+  let out = id.x * 4u;
+  results[out] = shaded.x;
+  results[out + 1u] = shaded.y;
+  results[out + 2u] = shaded.z;
+}
+`;

package/src/render/shaders/gpudriven/cull.wgsl.ts

@@ -104,9 +104,11 @@ struct Params {
   eyeZ: f32,
   /** Non-zero to select the blended clusters, zero to select everything else. */
   wantBlend: f32,
+  /** Non-zero to keep, of those, only glass: what the light's glass pass draws. */
+  wantGlass: f32,
 };
 ${MATERIAL_TABLE_WGSL}
-@group(0) @binding(0) var<storage, read> params: array<f32, 7>;
+@group(0) @binding(0) var<storage, read> params: array<f32, 8>;
 /** Six floats a cluster: centre, radius, own error, parent error. */
 @group(0) @binding(1) var<storage, read> clusters: array<f32>;
 @group(0) @binding(2) var<storage, read_write> selected: array<u32>;
@@ -139,11 +141,18 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
    * neither is drawn twice and neither is dropped. The flag is read through a uniform by an index
    * that is the same for every cluster of a mesh, so the branch is as coherent as this shader gets.
    */
-  let blended = materials[min(materialOf[i], ${MATERIAL_SLOTS - 1}u)].orm.w != 0.0;
+  let material = materials[min(materialOf[i], ${MATERIAL_SLOTS - 1}u)];
+  let blended = material.orm.w != 0.0;
   if (blended != (params[6] != 0.0)) {
     selected[i] = 0u;
     return;
   }
+  /* The light's glass pass: a blended surface that is not glass casts nothing, as on the forward
+     path, so only a material letting light through is kept. */
+  if (params[7] != 0.0 && material.extra.y <= 0.0) {
+    selected[i] = 0u;
+    return;
+  }
   let screenHeight = params[0];
   let fovY = params[1];
   let threshold = params[2];

package/src/render/shaders/gpudriven/materialTable.wgsl.ts

@@ -38,8 +38,10 @@ struct Material {
   maps: vec4<f32>,
   /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */
   orm: vec4<f32>,
-  /** The blended opacity, and three spare. */
+  /** The blended opacity, the glass's transmission and frost, and one spare. */
   extra: vec4<f32>,
+  /** The glass's tint, white where the material is not glass, and one spare. */
+  glassTint: vec4<f32>,
 }
 
 const NO_PROGRAM: u32 = ${DECODE_NO_PROGRAM}u;

package/src/render/shaders/gpudriven/shade.wgsl.ts

@@ -8,6 +8,7 @@ import { MATERIAL_SLOTS, MATERIAL_TABLE_WGSL } from './materialTable.wgsl.ts';
 import { MESH_TRANSFORM_WGSL } from './meshTransform.wgsl.ts';
 import { ENVIRONMENT_WGSL } from './environment.wgsl.ts';
 import { SHADE_SHADOW_WGSL } from './shadow.wgsl.ts';
+import { SUN_GLASS_WGSL } from './sunGlass.wgsl.ts';
 
 /**
  * Rebuilding a pixel's surface from the triangle it recorded, on the device.
@@ -514,6 +515,14 @@ struct Job {
 @group(0) @binding(12) var environmentMap: texture_2d_array<f32>;
 @group(0) @binding(13) var environmentSampler: sampler;
 ${decodeResourcesWgsl({ group: 0, latents: 14, clampSampler: 15, repeatSampler: 16, nodes: 17, weights: 18 })}
+/*
+ * **What the sun keeps through glass: the nearest pane's depth and what the panes let through**,
+ * which the pass draws from the sun after its opaque map. Where no material is glass the depth is
+ * the opaque map again and the tint a single white texel, which sunGlassAt reads as none.
+ */
+@group(0) @binding(19) var glassDepthMap: texture_depth_2d;
+@group(0) @binding(20) var glassTints: texture_2d<f32>;
+@group(0) @binding(21) var glassSampler: sampler;
 
 fn decodeLatentSize() -> f32 {
   return frame.size.w;
@@ -545,6 +554,45 @@ fn shadowDepthAt(u: f32, v: f32) -> f32 {
   return textureLoad(shadowMap, vec2<i32>(x, y), 0);
 }
 ${SHADE_SHADOW_WGSL}
+
+/* sunGlass.wgsl.ts's three reads, as the opaque map is read: nearest by integer coordinate. */
+fn glassDepthAt(u: f32, v: f32) -> f32 {
+  let size = frame.shadow.y;
+  let x = i32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = i32(clamp(floor(v * size), 0.0, size - 1.0));
+  return textureLoad(glassDepthMap, vec2<i32>(x, y), 0);
+}
+
+fn glassTintTexel(u: f32, v: f32) -> vec4<f32> {
+  let size = f32(textureDimensions(glassTints, 0).x);
+  let x = i32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = i32(clamp(floor(v * size), 0.0, size - 1.0));
+  return textureLoad(glassTints, vec2<i32>(x, y), 0);
+}
+
+/* The tint over a spread, from the chain: the level whose texel is the spread's width. */
+fn glassTintAround(u: f32, v: f32, radius: f32) -> vec4<f32> {
+  let size = f32(textureDimensions(glassTints, 0).x);
+  return textureSampleLevel(glassTints, glassSampler, vec2<f32>(u, v), log2(max(radius * size, 1.0)));
+}
+${SUN_GLASS_WGSL}
+
+/*
+ * The sun's colour at this receiver after the panes between it and the sun: white where no glass
+ * cast, and faded with the opaque shadow's own strength. The map's scale in metres comes off the
+ * light's matrix, which is orthographic: a compute invocation has no derivatives to take it from.
+ */
+fn sunGlassAt(lightPos: vec3<f32>) -> vec3<f32> {
+  if (textureDimensions(glassTints, 0).x <= 1u || frame.shadow.x <= 0.0) { return vec3<f32>(1.0); }
+  let m = frame.lightViewProj;
+  var settings: SunGlassSettings;
+  settings.mapSize = frame.shadow.y;
+  settings.depthSpan = frame.shadow.z;
+  settings.uvPerMetre = 0.5 * length(vec3<f32>(m[0][0], m[1][0], m[2][0]));
+  settings.taps = frame.shadowLimits.y;
+  let tint = sunGlass(lightPos.x * 0.5 + 0.5, lightPos.y * 0.5 + 0.5, lightPos.z, settings);
+  return mix(vec3<f32>(1.0), tint, frame.shadow.x);
+}
 ${ENVIRONMENT_WGSL}
 ${FOG_WGSL}
 
@@ -737,7 +785,8 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 
   var room: LitEnvironment;
   room.lightDir = frame.lightDir.xyz;
-  room.lightColour = frame.lightColour.xyz;
+  /* The sun's colour through whatever glass stands between it and here, as flat/main.ts's is. */
+  room.lightColour = frame.lightColour.xyz * sunGlassAt(lightPos);
   room.sky = frame.sky.xyz;
   room.ground = frame.ground.xyz;
   /*

package/src/render/shaders/gpudriven/sunGlass.wgsl.ts

@@ -0,0 +1,139 @@
+/**
+ * The sun through glass for the device: `gpudriven/sunGlass.ts`'s `glassTintAt`, term for term, as
+ * the text the shading pass and the parity entry point both include.
+ *
+ * **The reads are the including module's**, as `SHADE_SHADOW_WGSL`'s are: `glassDepthAt(u, v)` the
+ * nearest pane's depth, `glassTintTexel(u, v)` the tint at the finest level, and
+ * `glassTintAround(u, v, radius)` the tint averaged over a spread of that radius. The shading pass
+ * answers the last from the tint's mip chain; the parity entry answers it with the reference's own
+ * box average, so everything around the reads is checked as it stands. Every constant is the
+ * reference's, interpolated rather than restated.
+ */
+import { FROST_RADIUS_CAP, FROST_SPREAD } from '../../glassShadow.ts';
+import {
+  SHADOW_DEPTH_BIAS,
+  SHADOW_PCF_OFFSETS,
+  SHADOW_TEXEL_SCALE,
+} from '../../gpudriven/shadow.ts';
+import { SHADE_SHADOW_WGSL } from './shadow.wgsl.ts';
+
+export const SUN_GLASS_WGSL = /* wgsl */ `
+struct SunGlassSettings {
+  mapSize: f32,
+  depthSpan: f32,
+  uvPerMetre: f32,
+  taps: f32,
+}
+
+/*
+ * A coarse texel with the open ground's white taken back out, by how milky the pane at the
+ * receiver is: the pane's colour and its share of the texel. glassShadow.ts's unmixTint.
+ */
+fn sunGlassUnmix(mip: vec4<f32>, centreClarity: f32) -> vec4<f32> {
+  if (centreClarity >= 1.0) { return vec4<f32>(mip.xyz, 1.0); }
+  let share = clamp((1.0 - mip.w) / (1.0 - centreClarity), 0.0, 1.0);
+  if (share <= 0.0) { return vec4<f32>(1.0, 1.0, 1.0, 0.0); }
+  let colour = clamp((mip.xyz - vec3<f32>(1.0 - share)) / share, vec3<f32>(0.0), vec3<f32>(1.0));
+  return vec4<f32>(colour, share);
+}
+
+/* What the sun keeps through glass at map position (u, v) and light depth "depth". */
+fn sunGlass(u: f32, v: f32, depth: f32, settings: SunGlassSettings) -> vec3<f32> {
+  if (u < 0.0 || u > 1.0 || v < 0.0 || v > 1.0) { return vec3<f32>(1.0); }
+  let texel = ${SHADOW_TEXEL_SCALE.toFixed(4)} / settings.mapSize;
+  let bias = ${SHADOW_DEPTH_BIAS.toFixed(4)} / settings.depthSpan;
+  let taps = min(u32(settings.taps), ${SHADOW_PCF_OFFSETS.length}u);
+  let clarity = glassTintTexel(u, v).w;
+  let behind = max(depth - glassDepthAt(u, v), 0.0) * settings.depthSpan;
+  let spread = (1.0 - clarity) * ${FROST_SPREAD.toFixed(6)} * behind * settings.uvPerMetre;
+  let radius = min(max(texel, spread), texel * ${FROST_RADIUS_CAP.toFixed(1)});
+
+  var cover = 0.0;
+  var colour = vec3<f32>(0.0);
+  var found = 0.0;
+  for (var i = 0u; i < taps; i = i + 1u) {
+    let offset = SHADOW_TAPS[i];
+    /* The outline: a tap counts the pane only where the receiver is behind it, by the bias. */
+    if (depth > glassDepthAt(u + offset.x * texel, v + offset.y * texel) + bias) {
+      cover = cover + 1.0;
+    }
+    /* The colour: the spread's taps, each an average, unmixed and weighed by the pane's share. */
+    let pane = sunGlassUnmix(glassTintAround(u + offset.x * radius, v + offset.y * radius, radius), clarity);
+    colour = colour + pane.xyz * pane.w;
+    found = found + pane.w;
+  }
+  let mixed = select(vec3<f32>(1.0), colour / max(found, 1e-6), found > 0.0);
+  return mix(vec3<f32>(1.0), mixed, cover / f32(max(taps, 1u)));
+}
+`;
+
+/**
+ * `sunGlass` over maps held in storage buffers, read as the reference reads them, so the whole
+ * lookup can be compared with `glassTintAt` rather than only the arithmetic between the reads.
+ *
+ * Four floats a case in — u, v, the receiver's depth, one spare — and four out, the tint and one
+ * spare. The config is the map's size, the depth span, map units a metre, and the tap count.
+ */
+export const SUN_GLASS_PARITY_WGSL = /* wgsl */ `
+@group(0) @binding(0) var<storage, read> depths: array<f32>;
+@group(0) @binding(1) var<storage, read> tints: array<f32>;
+@group(0) @binding(2) var<storage, read> cases: array<f32>;
+@group(0) @binding(3) var<storage, read> config: array<f32>;
+@group(0) @binding(4) var<storage, read_write> results: array<f32>;
+
+/* The opaque lookup's own read, which this entry never calls: included only for its tap table. */
+fn shadowDepthAt(u: f32, v: f32) -> f32 { return 1.0; }
+${SHADE_SHADOW_WGSL}
+
+fn glassIndex(u: f32, v: f32) -> u32 {
+  let size = config[0];
+  let x = u32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = u32(clamp(floor(v * size), 0.0, size - 1.0));
+  return y * u32(size) + x;
+}
+
+fn glassDepthAt(u: f32, v: f32) -> f32 {
+  return depths[glassIndex(u, v)];
+}
+
+fn glassTintTexel(u: f32, v: f32) -> vec4<f32> {
+  let at = glassIndex(u, v) * 4u;
+  return vec4<f32>(tints[at], tints[at + 1u], tints[at + 2u], tints[at + 3u]);
+}
+
+/* The reference's coarse read: the average of every texel within the radius. */
+fn glassTintAround(u: f32, v: f32, radius: f32) -> vec4<f32> {
+  let size = config[0];
+  let reach = radius * size;
+  let x0 = u32(max(0.0, floor(u * size - reach)));
+  let x1 = u32(min(size - 1.0, floor(u * size + reach)));
+  let y0 = u32(max(0.0, floor(v * size - reach)));
+  let y1 = u32(min(size - 1.0, floor(v * size + reach)));
+  var sum = vec4<f32>(0.0);
+  var n = 0.0;
+  for (var y = y0; y <= y1; y = y + 1u) {
+    for (var x = x0; x <= x1; x = x + 1u) {
+      let at = (y * u32(size) + x) * 4u;
+      sum = sum + vec4<f32>(tints[at], tints[at + 1u], tints[at + 2u], tints[at + 3u]);
+      n = n + 1.0;
+    }
+  }
+  return sum / max(n, 1.0);
+}
+${SUN_GLASS_WGSL}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x * 4u + 3u >= arrayLength(&cases)) { return; }
+  var settings: SunGlassSettings;
+  settings.mapSize = config[0];
+  settings.depthSpan = config[1];
+  settings.uvPerMetre = config[2];
+  settings.taps = config[3];
+  let at = id.x * 4u;
+  let tint = sunGlass(cases[at], cases[at + 1u], cases[at + 2u], settings);
+  results[at] = tint.x;
+  results[at + 1u] = tint.y;
+  results[at + 2u] = tint.z;
+}
+`;

package/src/render/shaders/lightVolume.ts

@@ -47,6 +47,7 @@
  *   halves of one frame disagreeing about the same light.
  */
 
+import { SUN_DYNAMIC_LAYER, SUN_PEELED_LAYER, SUN_STATIC_LAYER } from '../shadowMap.ts';
 import { resolveConditionals } from './conditionals.ts';
 
 export const LIGHT_VOLUME_VERT = `#version 300 es
@@ -159,9 +160,8 @@ uniform vec3 uDustOffset;
 uniform float uSunShadow;
 uniform mat4 uLightViewProj;
 uniform float uShadowMapSize;
-uniform sampler2D uStaticShadowMap;
-uniform sampler2D uPeeledShadowMap;
-uniform sampler2D uDynamicShadowMap;
+/* The sun's static, moving and peeled maps, as layers of one array: see shadowMap.ts. */
+uniform highp sampler2DArray uSunShadows;
 uniform int uPeeledShadowEnabled;
 #endif
 
@@ -324,11 +324,11 @@ float sunReach(vec3 worldPos) {
   if (edgeFade <= 0.0) return 1.0;
 
   float compare = p.z - BIAS;
-  float blocked = occlusion(textureLod(uStaticShadowMap, p.xy, 0.0).r, compare);
+  float blocked = occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_STATIC_LAYER}.0), 0.0).r, compare);
   if (uPeeledShadowEnabled != 0) {
-    blocked = max(blocked, occlusion(textureLod(uPeeledShadowMap, p.xy, 0.0).r, compare));
+    blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_PEELED_LAYER}.0), 0.0).r, compare));
   }
-  blocked = max(blocked, occlusion(textureLod(uDynamicShadowMap, p.xy, 0.0).r, compare));
+  blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_DYNAMIC_LAYER}.0), 0.0).r, compare));
   return mix(1.0, 1.0 - blocked, uSunShadow * edgeFade);
 }
 #endif

package/src/render/shaders/octahedralResolve.ts

@@ -12,6 +12,30 @@ void main() {
   gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
 }`;
 
+/**
+ * Which cube face owns this octahedral texel, and where in that face it looks: `d`, `forward` and
+ * `faceUv`, with every texel another face owns discarded. **One text for both resolves**, depth
+ * and tint, because the tie-breaking has to agree with itself as well as with the CPU: a sliver
+ * of texels given to one face's depth and another face's colour is a tinted seam.
+ */
+const FACE_REGION = `  vec3 d = octDecode(gl_FragCoord.xy / uEdge);
+
+  /*
+   * Which face owns this texel. The tie-breaking is x, then y, then z, and it has to match the
+   * CPU's exactly or a sliver of texels along a boundary belongs to two faces or to none.
+   */
+  vec3 a = abs(d);
+  int face;
+  if (a.x >= a.y && a.x >= a.z) face = d.x >= 0.0 ? 0 : 1;
+  else if (a.y >= a.z) face = d.y >= 0.0 ? 2 : 3;
+  else face = d.z >= 0.0 ? 4 : 5;
+  if (face != uFaceIndex) discard;
+
+  /* lookAt looks down -z, so a direction inside this face has a negative z here. */
+  vec3 v = uFaceRotation * d;
+  float forward = -v.z;
+  vec2 faceUv = (v.xy / forward) * 0.5 + 0.5;`;
+
 /**
  * One cube face into its region of an octahedral map, as linear radial distance.
  *
@@ -46,23 +70,7 @@ uniform float uEdge;
 ${OCTAHEDRAL_GLSL}
 
 void main() {
-  vec3 d = octDecode(gl_FragCoord.xy / uEdge);
-
-  /*
-   * Which face owns this texel. The tie-breaking is x, then y, then z, and it has to match the
-   * CPU's exactly or a sliver of texels along a boundary belongs to two faces or to none.
-   */
-  vec3 a = abs(d);
-  int face;
-  if (a.x >= a.y && a.x >= a.z) face = d.x >= 0.0 ? 0 : 1;
-  else if (a.y >= a.z) face = d.y >= 0.0 ? 2 : 3;
-  else face = d.z >= 0.0 ? 4 : 5;
-  if (face != uFaceIndex) discard;
-
-  /* lookAt looks down -z, so a direction inside this face has a negative z here. */
-  vec3 v = uFaceRotation * d;
-  float forward = -v.z;
-  vec2 faceUv = (v.xy / forward) * 0.5 + 0.5;
+${FACE_REGION}
 
   /*
    * textureLod at level zero rather than plain texture. The scratch carries one storage level and
@@ -81,3 +89,28 @@ void main() {
   /* d is a unit vector, so forward is its cosine to the axis and this is the true radius. */
   gl_FragDepth = clamp((faceLocalZ / forward) / uFar, 0.0, 1.0);
 }`;
+
+/**
+ * One face of a lamp's glass tint into its region of the tint layer: the depth resolve's region,
+ * and a colour copied rather than a depth decoded.
+ *
+ * **Nearest, at level zero**, like the depth beside it: the tint's outline has to land on the
+ * glass depth's texels, and a filtered copy would smear a pane's colour a texel past its edge.
+ */
+export const OCTAHEDRAL_RESOLVE_TINT_FRAG = `#version 300 es
+precision highp float;
+
+/** The face the bake just tinted, as colour. */
+uniform highp sampler2D uFace;
+uniform mat3 uFaceRotation;
+uniform int uFaceIndex;
+uniform float uEdge;
+
+out vec4 outTint;
+
+${OCTAHEDRAL_GLSL}
+
+void main() {
+${FACE_REGION}
+  outTint = textureLod(uFace, faceUv, 0.0);
+}`;