@driftengine/core 4.4.1 → 4.5.0

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);
+}`;

package/src/render/shaders/recon/lateDepth.wgsl.ts

@@ -0,0 +1,47 @@
+/**
+ * The render's depth, taken up to the output size for the draws that land after the upscale.
+ *
+ * **The nearest of the four render texels around each output pixel**, so a translucent draw is
+ * never let through an opaque edge the render did cover. What it gives up: where a translucent
+ * surface crosses an opaque silhouette, the edge steps at the render's resolution.
+ *
+ * Hand-written, and built by concatenation rather than a template literal: the reconstruction's
+ * passes have no WebGL2 twin (the AGENTS.md exception for them), and a `${}` inside WGSL source is
+ * the thing that rule forbids.
+ */
+import { REVERSED_DEPTH } from '../../depthConvention.ts';
+
+/** The nearer of two stored depths: the larger in a reversed buffer. */
+const NEARER = REVERSED_DEPTH ? 'max' : 'min';
+/** Where the search for the nearest starts: the far plane. */
+const FARTHEST = REVERSED_DEPTH ? '0.0' : '1.0';
+
+export const LATE_DEPTH_WGSL =
+  '@group(0) @binding(0) var source: texture_depth_2d;\n' +
+  '@group(0) @binding(1) var<uniform> sizes: vec4<f32>;\n' +
+  '\n' +
+  '@vertex\n' +
+  'fn lateDepthVert(@builtin(vertex_index) index: u32) -> @builtin(position) vec4<f32> {\n' +
+  '  let x = f32((index << 1u) & 2u);\n' +
+  '  let y = f32(index & 2u);\n' +
+  '  return vec4<f32>(x * 2.0 - 1.0, 1.0 - y * 2.0, 0.0, 1.0);\n' +
+  '}\n' +
+  '\n' +
+  '@fragment\n' +
+  'fn lateDepthFrag(@builtin(position) at: vec4<f32>) -> @builtin(frag_depth) f32 {\n' +
+  '  let centre = at.xy * sizes.xy / sizes.zw - vec2<f32>(0.5);\n' +
+  '  let base = vec2<i32>(floor(centre));\n' +
+  '  let top = vec2<i32>(sizes.xy) - vec2<i32>(1);\n' +
+  '  var nearest = ' +
+  FARTHEST +
+  ';\n' +
+  '  for (var y = 0; y < 2; y += 1) {\n' +
+  '    for (var x = 0; x < 2; x += 1) {\n' +
+  '      let texel = clamp(base + vec2<i32>(x, y), vec2<i32>(0), top);\n' +
+  '      nearest = ' +
+  NEARER +
+  '(nearest, textureLoad(source, texel, 0));\n' +
+  '    }\n' +
+  '  }\n' +
+  '  return nearest;\n' +
+  '}\n';

package/src/render/shaders/recon/motion.wgsl.ts

@@ -88,6 +88,90 @@ fn motionUv(clip: vec4<f32>) -> vec2<f32> {
   return clip.xy / clip.w * 0.5 + vec2<f32>(0.5);
 }
 
+/*
+ * The skinned stage: the joints this frame and last frame, read from two palette textures of the
+ * frame's ring. The same four weighted products in the same order as the scene's own skinning, so
+ * the depth this stage produces is the depth the scene wrote.
+ */
+@group(1) @binding(0) var palette: texture_2d<f32>;
+@group(1) @binding(1) var previousPalette: texture_2d<f32>;
+
+fn jointOf(source: texture_2d<f32>, index: i32) -> mat4x4<f32> {
+  let x = index * 4;
+  return mat4x4<f32>(
+    textureLoad(source, vec2<i32>(x, 0), 0),
+    textureLoad(source, vec2<i32>(x + 1, 0), 0),
+    textureLoad(source, vec2<i32>(x + 2, 0), 0),
+    textureLoad(source, vec2<i32>(x + 3, 0), 0));
+}
+
+fn skinOf(source: texture_2d<f32>, joints: vec4<f32>, weights: vec4<f32>) -> mat4x4<f32> {
+  return jointOf(source, i32(joints.x)) * weights.x
+       + jointOf(source, i32(joints.y)) * weights.y
+       + jointOf(source, i32(joints.z)) * weights.z
+       + jointOf(source, i32(joints.w)) * weights.w;
+}
+
+@vertex
+fn motionSkinnedVert(
+  @location(0) position: vec3<f32>,
+  @location(11) joints: vec4<f32>,
+  @location(12) weights: vec4<f32>,
+) -> Varyings {
+  let world = draw.model * (skinOf(palette, joints, weights) * vec4<f32>(position, 1.0));
+  let wasWorld =
+    draw.previousModel * (skinOf(previousPalette, joints, weights) * vec4<f32>(position, 1.0));
+  var out: Varyings;
+  out.clip = frame.raster * world;
+  out.now = frame.viewProj * world;
+  out.was = frame.previousViewProj * wasWorld;
+  return out;
+}
+
+/*
+ * The rewritten stage: a mesh whose vertices were rewritten this frame reads last frame's rows from
+ * a second buffer of the same stride, so each vertex carries both of its positions.
+ */
+@vertex
+fn motionDynamicVert(
+  @location(0) position: vec3<f32>,
+  @location(1) previousPosition: vec3<f32>,
+) -> Varyings {
+  let world = draw.model * vec4<f32>(position, 1.0);
+  let wasWorld = draw.previousModel * vec4<f32>(previousPosition, 1.0);
+  var out: Varyings;
+  out.clip = frame.raster * world;
+  out.now = frame.viewProj * world;
+  out.was = frame.previousViewProj * wasWorld;
+  return out;
+}
+
+/*
+ * The instanced stage: each instance's matrix this frame and last frame, read from the batch's
+ * placement and the copy of last frame's it kept. Slot for slot, so an instance is paired with
+ * itself; the per-draw matrices are not read.
+ */
+@vertex
+fn motionInstancedVert(
+  @location(0) position: vec3<f32>,
+  @location(2) m0: vec4<f32>,
+  @location(3) m1: vec4<f32>,
+  @location(4) m2: vec4<f32>,
+  @location(5) m3: vec4<f32>,
+  @location(6) p0: vec4<f32>,
+  @location(7) p1: vec4<f32>,
+  @location(8) p2: vec4<f32>,
+  @location(9) p3: vec4<f32>,
+) -> Varyings {
+  let world = mat4x4<f32>(m0, m1, m2, m3) * vec4<f32>(position, 1.0);
+  let wasWorld = mat4x4<f32>(p0, p1, p2, p3) * vec4<f32>(position, 1.0);
+  var out: Varyings;
+  out.clip = frame.raster * world;
+  out.now = frame.viewProj * world;
+  out.was = frame.previousViewProj * wasWorld;
+  return out;
+}
+
 @fragment
 fn motionFrag(in: Varyings) -> @location(0) vec4<f32> {
   /*

package/src/render/shaders/recon/resolve.wgsl.ts

@@ -39,6 +39,7 @@
  * and the uniform `recon: ReconParams`, whose struct this module declares.
  */
 import { wgslSceneDepthToNdc } from '../../depthConvention.ts';
+import { PLANAR_FROM, PLANAR_TO } from '../../recon/disocclusion.ts';
 
 /**
  * The parameters one resolve reads, as `ResolveFrame` minus its images.
@@ -97,6 +98,8 @@ export const RECON_HISTORY_FORMAT: GPUTextureFormat = 'rgba16float';
 export const RECON_RESOLVE_CORE_WGSL = /* wgsl */ `
 const RECON_SAMPLE_SPREAD: f32 = ${RECON_SAMPLE_SPREAD};
 const RECON_CONFIDENT_WEIGHT: f32 = ${RECON_CONFIDENT_WEIGHT}.0;
+const RECON_PLANAR_FROM: f32 = ${PLANAR_FROM};
+const RECON_PLANAR_TO: f32 = ${PLANAR_TO};
 
 fn reconClampTexel(value: i32, size: i32) -> i32 {
   return clamp(value, 0, size - 1);
@@ -328,10 +331,11 @@ fn reconDisocclusion(
   histDepth: f32,
   motionLength: f32,
   normalDot: f32,
+  slope: f32,
 ) -> f32 {
   if (!(currDepth > 0.0) || !(histDepth > 0.0) || !(motionLength >= 0.0)) { return 0.0; }
   let disagreement = abs(currDepth - histDepth) / currDepth;
-  let tolerance = recon.depthTolerance + recon.motionScale * motionLength;
+  let tolerance = recon.depthTolerance + recon.motionScale * motionLength + slope;
   let depth = 1.0 - reconSmoothstep(tolerance, 2.0 * tolerance, disagreement);
   let normal = reconSmoothstep(recon.normalFloor, recon.normalCeiling, normalDot);
   return depth * normal;
@@ -392,6 +396,74 @@ fn reconNormalAt(previous: bool, x: i32, y: i32) -> ReconNormal {
   return reconNormalFrom(centre.position, right.position, up.position, eye);
 }
 
+/* resolve.ts's viewDepthAt. */
+fn reconViewDepthAt(previous: bool, x: i32, y: i32) -> f32 {
+  let w = i32(recon.renderSize.x);
+  let h = i32(recon.renderSize.y);
+  if (x < 0 || y < 0 || x >= w || y >= h) { return 0.0; }
+  var jitter = recon.jitter;
+  var m = recon.inverseViewProj;
+  var z = 0.0;
+  if (previous) {
+    jitter = recon.previousJitter;
+    m = recon.previousInverseViewProj;
+    z = reconPreviousDepth(x, y);
+  } else {
+    z = reconDepth(x, y);
+  }
+  let u = (f32(x) + 0.5 - jitter.x) / f32(w);
+  let v = (f32(y) + 0.5 - jitter.y) / f32(h);
+  let cw = m[0][3] * (u * 2.0 - 1.0) + m[1][3] * (v * 2.0 - 1.0) + m[2][3] * z + m[3][3];
+  if (!(abs(cw) > 1e-12)) { return 0.0; }
+  return 1.0 / cw;
+}
+
+/* disocclusion.ts's planarity. */
+fn reconPlanarity(before: f32, centre: f32, after: f32) -> f32 {
+  if (!(before > 0.0) || !(centre > 0.0) || !(after > 0.0)) { return 1.0; }
+  let a = 1.0 / after - 1.0 / centre;
+  let b = 1.0 / before - 1.0 / centre;
+  let spread = abs(a) + abs(b);
+  if (!(spread > 0.0)) { return 1.0; }
+  return 1.0 - reconSmoothstep(RECON_PLANAR_FROM, RECON_PLANAR_TO, abs(a + b) / spread);
+}
+
+/* disocclusion.ts's surfaceSlope. */
+fn reconSurfaceSlope(before: f32, centre: f32, after: f32) -> f32 {
+  let hasAfter = after > 0.0;
+  let hasBefore = before > 0.0;
+  if (!hasAfter) {
+    if (!hasBefore) { return 0.0; }
+    return abs(before - centre) / centre;
+  }
+  if (!hasBefore) { return abs(after - centre) / centre; }
+  let a = after - centre;
+  let b = before - centre;
+  if (a * b > 0.0) { return 0.0; }
+  return min(abs(a), abs(b)) / centre;
+}
+
+struct ReconSurface {
+  planar: f32,
+  slope: f32,
+}
+
+/* resolve.ts's surfaceAt. */
+fn reconSurfaceAt(previous: bool, x: i32, y: i32, centre: f32) -> ReconSurface {
+  var out: ReconSurface;
+  out.planar = 1.0;
+  out.slope = 0.0;
+  for (var axis = 0; axis < 2; axis = axis + 1) {
+    let ax = 1 - axis;
+    let ay = axis;
+    let after = reconViewDepthAt(previous, x + ax, y + ay);
+    let before = reconViewDepthAt(previous, x - ax, y - ay);
+    out.planar = out.planar * reconPlanarity(before, centre, after);
+    out.slope = max(out.slope, reconSurfaceSlope(before, centre, after));
+  }
+  return out;
+}
+
 struct ReconHistory {
   weight: f32,
   colour: vec4<f32>,
@@ -439,14 +511,46 @@ fn reconHistoryWeight(u: f32, v: f32, dx: i32, dy: i32) -> ReconHistory {
     pu * f32(recon.outputSize.x) - 0.5,
     pv * f32(recon.outputSize.y) - 0.5,
   );
-  let px = reconClampTexel(i32(reconRound(pu * rw + recon.previousJitter.x - 0.5)), i32(rw));
-  let py = reconClampTexel(i32(reconRound(pv * rh + recon.previousJitter.y - 0.5)), i32(rh));
-  let held = reconWorldAt(true, px, py).depth;
+  /* Last frame's depth, searched around where the dilated texel was: see resolve.ts. */
+  let su = (f32(dx) + 0.5 - recon.jitter.x) / rw + mu;
+  let sv = (f32(dy) + 0.5 - recon.jitter.y) / rh + mv;
+  let cx = reconClampTexel(i32(reconRound(su * rw + recon.previousJitter.x - 0.5)), i32(rw));
+  let cy = reconClampTexel(i32(reconRound(sv * rh + recon.previousJitter.y - 0.5)), i32(rh));
+  var held = reconViewDepthAt(true, cx, cy);
+  var px = cx;
+  var py = cy;
+  if (!(held > 0.0 && abs(held - expected) <= recon.depthTolerance * expected)) {
+    held = 0.0;
+    var nearest = 3.4e38;
+    for (var j = -1; j <= 1; j = j + 1) {
+      for (var i = -1; i <= 1; i = i + 1) {
+        let tx = reconClampTexel(cx + i, i32(rw));
+        let ty = reconClampTexel(cy + j, i32(rh));
+        let depth = reconViewDepthAt(true, tx, ty);
+        if (!(depth > 0.0)) { continue; }
+        let off = abs(depth - expected);
+        if (off < nearest) {
+          nearest = off;
+          held = depth;
+          px = tx;
+          py = ty;
+        }
+      }
+    }
+  }
+
+  let here = reconSurfaceAt(false, dx, dy, reconViewDepthAt(false, dx, dy));
+  var planar = here.planar;
+  if (planar > 0.0) { planar = planar * reconSurfaceAt(true, px, py, held).planar; }
   var normalDot = 1.0;
-  let here = reconNormalAt(false, dx, dy);
-  let there = reconNormalAt(true, px, py);
-  if (here.ok && there.ok) { normalDot = dot(here.normal, there.normal); }
-  let trust = reconDisocclusion(expected, held, length(vec2<f32>(mu, mv)), normalDot);
+  if (planar > 0.0) {
+    let hereNormal = reconNormalAt(false, dx, dy);
+    let thereNormal = reconNormalAt(true, px, py);
+    if (hereNormal.ok && thereNormal.ok) {
+      normalDot = 1.0 - planar * (1.0 - dot(hereNormal.normal, thereNormal.normal));
+    }
+  }
+  let trust = reconDisocclusion(expected, held, length(vec2<f32>(mu, mv)), normalDot, here.slope);
   out.weight = out.colour.w * trust;
   return out;
 }