@driftengine/core 4.4.1 → 4.5.0

package/dist/render/shaders/lightVolume.js

@@ -46,6 +46,7 @@
  *   the window it came through, and without it a barred floor under a smooth shaft is two
  *   halves of one frame disagreeing about the same light.
  */
+import { SUN_DYNAMIC_LAYER, SUN_PEELED_LAYER, SUN_STATIC_LAYER } from '../shadowMap.js';
 import { resolveConditionals } from './conditionals.js';
 export const LIGHT_VOLUME_VERT = `#version 300 es
 precision highp float;
@@ -143,9 +144,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
 
@@ -308,11 +308,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/dist/render/shaders/octahedralResolve.d.ts

@@ -23,3 +23,11 @@ export declare const OCTAHEDRAL_RESOLVE_VERT = "#version 300 es\nvoid main() {\n
  * redeclaration and GLSL rejects the whole shader.
  */
 export declare const OCTAHEDRAL_RESOLVE_FRAG = "#version 300 es\nprecision highp float;\n\n/** The face the bake just rendered, as a depth texture. */\nuniform highp sampler2D uFace;\n/** That face's world-to-face rotation. See pointShadowFaceRotation. */\nuniform mat3 uFaceRotation;\n/** Which of the six this pass is resolving. Every other texel discards. */\nuniform int uFaceIndex;\nuniform float uFar;\nuniform float uNear;\n/** The octahedral map's edge, so this needs no viewport query. */\nuniform float uEdge;\n\nvec2 octEncode(vec3 d) {\n  vec3 n = d / (abs(d.x) + abs(d.y) + abs(d.z));\n  vec2 p = n.z >= 0.0\n    ? n.xy\n    : (1.0 - abs(vec2(n.y, n.x))) * vec2(n.x >= 0.0 ? 1.0 : -1.0, n.y >= 0.0 ? 1.0 : -1.0);\n  return p * 0.5 + 0.5;\n}\n\nvec3 octDecode(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  vec3 n = vec3(f.x, f.y, 1.0 - abs(f.x) - abs(f.y));\n  float t = max(-n.z, 0.0);\n  n.x += n.x >= 0.0 ? -t : t;\n  n.y += n.y >= 0.0 ? -t : t;\n  return normalize(n);\n}\n\nvec2 octWrapUv(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  if (f.x < -1.0 || f.x > 1.0) {\n    f.x = (f.x > 0.0 ? 2.0 : -2.0) - f.x;\n    f.y = -f.y;\n  }\n  if (f.y < -1.0 || f.y > 1.0) {\n    f.y = (f.y > 0.0 ? 2.0 : -2.0) - f.y;\n    f.x = -f.x;\n  }\n  return f * 0.5 + 0.5;\n}\n\nvec2 octInsetUv(vec3 d, float edge) {\n  return (octEncode(d) * (edge - 2.0) + 1.0) / edge;\n}\n\nvec3 octInsetDir(vec2 uv, float edge) {\n  return octDecode(octWrapUv((uv * edge - 1.0) / (edge - 2.0)));\n}\n\nvoid main() {\n  vec3 d = octDecode(gl_FragCoord.xy / uEdge);\n\n  /*\n   * Which face owns this texel. The tie-breaking is x, then y, then z, and it has to match the\n   * CPU's exactly or a sliver of texels along a boundary belongs to two faces or to none.\n   */\n  vec3 a = abs(d);\n  int face;\n  if (a.x >= a.y && a.x >= a.z) face = d.x >= 0.0 ? 0 : 1;\n  else if (a.y >= a.z) face = d.y >= 0.0 ? 2 : 3;\n  else face = d.z >= 0.0 ? 4 : 5;\n  if (face != uFaceIndex) discard;\n\n  /* lookAt looks down -z, so a direction inside this face has a negative z here. */\n  vec3 v = uFaceRotation * d;\n  float forward = -v.z;\n  vec2 faceUv = (v.xy / forward) * 0.5 + 0.5;\n\n  /*\n   * textureLod at level zero rather than plain texture. The scratch carries one storage level and\n   * NEAREST filtering so the fetch is identical, and this call sits after a discard \u2014 which is\n   * non-uniform control flow, where an implicit derivative is undefined in GLSL and rejected\n   * outright in WGSL. AGENTS.md, 2026-08-07.\n   */\n  float stored = textureLod(uFace, faceUv, 0.0).r;\n  if (stored >= 0.9999) {\n    /* Nothing was rendered along this direction, so the stored radius is the far plane. */\n    gl_FragDepth = 1.0;\n    return;\n  }\n  float ndc = stored * 2.0 - 1.0;\n  float faceLocalZ = (2.0 * uFar * uNear) / (uFar + uNear - ndc * (uFar - uNear));\n  /* d is a unit vector, so forward is its cosine to the axis and this is the true radius. */\n  gl_FragDepth = clamp((faceLocalZ / forward) / uFar, 0.0, 1.0);\n}";
+/**
+ * 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 declare const OCTAHEDRAL_RESOLVE_TINT_FRAG = "#version 300 es\nprecision highp float;\n\n/** The face the bake just tinted, as colour. */\nuniform highp sampler2D uFace;\nuniform mat3 uFaceRotation;\nuniform int uFaceIndex;\nuniform float uEdge;\n\nout vec4 outTint;\n\nvec2 octEncode(vec3 d) {\n  vec3 n = d / (abs(d.x) + abs(d.y) + abs(d.z));\n  vec2 p = n.z >= 0.0\n    ? n.xy\n    : (1.0 - abs(vec2(n.y, n.x))) * vec2(n.x >= 0.0 ? 1.0 : -1.0, n.y >= 0.0 ? 1.0 : -1.0);\n  return p * 0.5 + 0.5;\n}\n\nvec3 octDecode(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  vec3 n = vec3(f.x, f.y, 1.0 - abs(f.x) - abs(f.y));\n  float t = max(-n.z, 0.0);\n  n.x += n.x >= 0.0 ? -t : t;\n  n.y += n.y >= 0.0 ? -t : t;\n  return normalize(n);\n}\n\nvec2 octWrapUv(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  if (f.x < -1.0 || f.x > 1.0) {\n    f.x = (f.x > 0.0 ? 2.0 : -2.0) - f.x;\n    f.y = -f.y;\n  }\n  if (f.y < -1.0 || f.y > 1.0) {\n    f.y = (f.y > 0.0 ? 2.0 : -2.0) - f.y;\n    f.x = -f.x;\n  }\n  return f * 0.5 + 0.5;\n}\n\nvec2 octInsetUv(vec3 d, float edge) {\n  return (octEncode(d) * (edge - 2.0) + 1.0) / edge;\n}\n\nvec3 octInsetDir(vec2 uv, float edge) {\n  return octDecode(octWrapUv((uv * edge - 1.0) / (edge - 2.0)));\n}\n\nvoid main() {\n  vec3 d = octDecode(gl_FragCoord.xy / uEdge);\n\n  /*\n   * Which face owns this texel. The tie-breaking is x, then y, then z, and it has to match the\n   * CPU's exactly or a sliver of texels along a boundary belongs to two faces or to none.\n   */\n  vec3 a = abs(d);\n  int face;\n  if (a.x >= a.y && a.x >= a.z) face = d.x >= 0.0 ? 0 : 1;\n  else if (a.y >= a.z) face = d.y >= 0.0 ? 2 : 3;\n  else face = d.z >= 0.0 ? 4 : 5;\n  if (face != uFaceIndex) discard;\n\n  /* lookAt looks down -z, so a direction inside this face has a negative z here. */\n  vec3 v = uFaceRotation * d;\n  float forward = -v.z;\n  vec2 faceUv = (v.xy / forward) * 0.5 + 0.5;\n  outTint = textureLod(uFace, faceUv, 0.0);\n}";

package/dist/render/shaders/octahedralResolve.js

@@ -10,6 +10,29 @@ void main() {
   vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
   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.
  *
@@ -44,23 +67,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
@@ -79,3 +86,27 @@ 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/dist/render/shaders/recon/lateDepth.wgsl.d.ts

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

package/dist/render/shaders/recon/lateDepth.wgsl.js

@@ -0,0 +1,44 @@
+/**
+ * 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.js';
+/** 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/dist/render/shaders/recon/motion.wgsl.d.ts

@@ -41,4 +41,4 @@ export declare const MOTION_DRAW_STRIDE = 256;
 export declare const MOTION_DRAW_FLOATS = 32;
 /** The motion target's format. Half float holds a uv to a hundredth of a pixel and a view depth. */
 export declare const MOTION_TARGET_FORMAT: GPUTextureFormat;
-export declare const RECON_MOTION_WGSL = "\nstruct MotionFrame {\n  /* The scene's own clip transform, with the generated shaders' y negation already folded in. */\n  raster: mat4x4<f32>,\n  /* This frame's and last frame's view-projections, unjittered, in the matrices' own convention. */\n  viewProj: mat4x4<f32>,\n  previousViewProj: mat4x4<f32>,\n}\n\nstruct MotionDraw {\n  model: mat4x4<f32>,\n  previousModel: mat4x4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> frame: MotionFrame;\n@group(0) @binding(1) var<uniform> draw: MotionDraw;\n\nstruct Varyings {\n  @builtin(position) clip: vec4<f32>,\n  /* Clip positions rather than uv: an interpolator divides by w for us, so dividing these by their\n     own interpolated w in the fragment stage is the perspective-correct answer at every pixel. */\n  @location(0) now: vec4<f32>,\n  @location(1) was: vec4<f32>,\n}\n\n@vertex\nfn motionVert(@location(0) position: vec3<f32>) -> Varyings {\n  let world = draw.model * vec4<f32>(position, 1.0);\n  let wasWorld = draw.previousModel * vec4<f32>(position, 1.0);\n  var out: Varyings;\n  out.clip = frame.raster * world;\n  out.now = frame.viewProj * world;\n  out.was = frame.previousViewProj * wasWorld;\n  return out;\n}\n\n/* Normalised device coordinates to the uv the resolve measures in: v increases upward, as the\n   references' images do, and the accessor that reads this target is what flips the texture's rows. */\nfn motionUv(clip: vec4<f32>) -> vec2<f32> {\n  return clip.xy / clip.w * 0.5 + vec2<f32>(0.5);\n}\n\n@fragment\nfn motionFrag(in: Varyings) -> @location(0) vec4<f32> {\n  /*\n   * A surface behind last frame's eye has a w that is not positive, and there is no uv for it. The\n   * flag stays set: the disocclusion refuses a depth that is not positive, so the resolve drops the\n   * history rather than reading it from wherever a divide by a negative w would have pointed.\n   */\n  let offset = select(vec2<f32>(0.0), motionUv(in.was) - motionUv(in.now), in.was.w > 0.0);\n  return vec4<f32>(offset, in.was.w, 1.0);\n}\n";
+export declare const RECON_MOTION_WGSL = "\nstruct MotionFrame {\n  /* The scene's own clip transform, with the generated shaders' y negation already folded in. */\n  raster: mat4x4<f32>,\n  /* This frame's and last frame's view-projections, unjittered, in the matrices' own convention. */\n  viewProj: mat4x4<f32>,\n  previousViewProj: mat4x4<f32>,\n}\n\nstruct MotionDraw {\n  model: mat4x4<f32>,\n  previousModel: mat4x4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> frame: MotionFrame;\n@group(0) @binding(1) var<uniform> draw: MotionDraw;\n\nstruct Varyings {\n  @builtin(position) clip: vec4<f32>,\n  /* Clip positions rather than uv: an interpolator divides by w for us, so dividing these by their\n     own interpolated w in the fragment stage is the perspective-correct answer at every pixel. */\n  @location(0) now: vec4<f32>,\n  @location(1) was: vec4<f32>,\n}\n\n@vertex\nfn motionVert(@location(0) position: vec3<f32>) -> Varyings {\n  let world = draw.model * vec4<f32>(position, 1.0);\n  let wasWorld = draw.previousModel * vec4<f32>(position, 1.0);\n  var out: Varyings;\n  out.clip = frame.raster * world;\n  out.now = frame.viewProj * world;\n  out.was = frame.previousViewProj * wasWorld;\n  return out;\n}\n\n/* Normalised device coordinates to the uv the resolve measures in: v increases upward, as the\n   references' images do, and the accessor that reads this target is what flips the texture's rows. */\nfn motionUv(clip: vec4<f32>) -> vec2<f32> {\n  return clip.xy / clip.w * 0.5 + vec2<f32>(0.5);\n}\n\n/*\n * The skinned stage: the joints this frame and last frame, read from two palette textures of the\n * frame's ring. The same four weighted products in the same order as the scene's own skinning, so\n * the depth this stage produces is the depth the scene wrote.\n */\n@group(1) @binding(0) var palette: texture_2d<f32>;\n@group(1) @binding(1) var previousPalette: texture_2d<f32>;\n\nfn jointOf(source: texture_2d<f32>, index: i32) -> mat4x4<f32> {\n  let x = index * 4;\n  return mat4x4<f32>(\n    textureLoad(source, vec2<i32>(x, 0), 0),\n    textureLoad(source, vec2<i32>(x + 1, 0), 0),\n    textureLoad(source, vec2<i32>(x + 2, 0), 0),\n    textureLoad(source, vec2<i32>(x + 3, 0), 0));\n}\n\nfn skinOf(source: texture_2d<f32>, joints: vec4<f32>, weights: vec4<f32>) -> mat4x4<f32> {\n  return jointOf(source, i32(joints.x)) * weights.x\n       + jointOf(source, i32(joints.y)) * weights.y\n       + jointOf(source, i32(joints.z)) * weights.z\n       + jointOf(source, i32(joints.w)) * weights.w;\n}\n\n@vertex\nfn motionSkinnedVert(\n  @location(0) position: vec3<f32>,\n  @location(11) joints: vec4<f32>,\n  @location(12) weights: vec4<f32>,\n) -> Varyings {\n  let world = draw.model * (skinOf(palette, joints, weights) * vec4<f32>(position, 1.0));\n  let wasWorld =\n    draw.previousModel * (skinOf(previousPalette, joints, weights) * vec4<f32>(position, 1.0));\n  var out: Varyings;\n  out.clip = frame.raster * world;\n  out.now = frame.viewProj * world;\n  out.was = frame.previousViewProj * wasWorld;\n  return out;\n}\n\n/*\n * The rewritten stage: a mesh whose vertices were rewritten this frame reads last frame's rows from\n * a second buffer of the same stride, so each vertex carries both of its positions.\n */\n@vertex\nfn motionDynamicVert(\n  @location(0) position: vec3<f32>,\n  @location(1) previousPosition: vec3<f32>,\n) -> Varyings {\n  let world = draw.model * vec4<f32>(position, 1.0);\n  let wasWorld = draw.previousModel * vec4<f32>(previousPosition, 1.0);\n  var out: Varyings;\n  out.clip = frame.raster * world;\n  out.now = frame.viewProj * world;\n  out.was = frame.previousViewProj * wasWorld;\n  return out;\n}\n\n/*\n * The instanced stage: each instance's matrix this frame and last frame, read from the batch's\n * placement and the copy of last frame's it kept. Slot for slot, so an instance is paired with\n * itself; the per-draw matrices are not read.\n */\n@vertex\nfn motionInstancedVert(\n  @location(0) position: vec3<f32>,\n  @location(2) m0: vec4<f32>,\n  @location(3) m1: vec4<f32>,\n  @location(4) m2: vec4<f32>,\n  @location(5) m3: vec4<f32>,\n  @location(6) p0: vec4<f32>,\n  @location(7) p1: vec4<f32>,\n  @location(8) p2: vec4<f32>,\n  @location(9) p3: vec4<f32>,\n) -> Varyings {\n  let world = mat4x4<f32>(m0, m1, m2, m3) * vec4<f32>(position, 1.0);\n  let wasWorld = mat4x4<f32>(p0, p1, p2, p3) * vec4<f32>(position, 1.0);\n  var out: Varyings;\n  out.clip = frame.raster * world;\n  out.now = frame.viewProj * world;\n  out.was = frame.previousViewProj * wasWorld;\n  return out;\n}\n\n@fragment\nfn motionFrag(in: Varyings) -> @location(0) vec4<f32> {\n  /*\n   * A surface behind last frame's eye has a w that is not positive, and there is no uv for it. The\n   * flag stays set: the disocclusion refuses a depth that is not positive, so the resolve drops the\n   * history rather than reading it from wherever a divide by a negative w would have pointed.\n   */\n  let offset = select(vec2<f32>(0.0), motionUv(in.was) - motionUv(in.now), in.was.w > 0.0);\n  return vec4<f32>(offset, in.was.w, 1.0);\n}\n";

package/dist/render/shaders/recon/motion.wgsl.js

@@ -83,6 +83,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/dist/render/shaders/recon/resolve.wgsl.d.ts

@@ -27,7 +27,7 @@ export declare const RECON_HISTORY_FORMAT: GPUTextureFormat;
  * colour and the weight it has gathered — and `reconSharpenAt(ox, oy) -> vec3<f32>`, the picture
  * shown, which reads the history the first has already written.
  */
-export declare const RECON_RESOLVE_CORE_WGSL = "\nconst RECON_SAMPLE_SPREAD: f32 = 0.47;\nconst RECON_CONFIDENT_WEIGHT: f32 = 1.0;\n\nfn reconClampTexel(value: i32, size: i32) -> i32 {\n  return clamp(value, 0, size - 1);\n}\n\n/* JavaScript's Math.round, which is not WGSL's round: a half goes up, not to even. */\nfn reconRound(value: f32) -> f32 {\n  return floor(value + 0.5);\n}\n\n/* Written out rather than the built-in, whose result is undefined where the edges are equal. */\nfn reconSmoothstep(edge0: f32, edge1: f32, x: f32) -> f32 {\n  let t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n  return t * t * (3.0 - 2.0 * t);\n}\n\nfn reconWeightAt(dx: f32, dy: f32) -> f32 {\n  return exp(-(dx * dx + dy * dy) / (2.0 * RECON_SAMPLE_SPREAD * RECON_SAMPLE_SPREAD));\n}\n\nfn reconToYCoCg(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(\n    c.r * 0.25 + c.g * 0.5 + c.b * 0.25,\n    c.r * 0.5 - c.b * 0.5,\n    -c.r * 0.25 + c.g * 0.5 - c.b * 0.25,\n  );\n}\n\nfn reconFromYCoCg(c: vec3<f32>) -> vec3<f32> {\n  let base = c.x - c.z;\n  return vec3<f32>(base + c.y, c.x + c.z, base - c.y);\n}\n\nstruct ReconBox {\n  low: vec3<f32>,\n  high: vec3<f32>,\n}\n\n/*\n * Each channel's mean plus or minus gamma of its standard deviation \u2014 and a channel whose nine\n * samples all agree is that value exactly, because a mean of nine equal floats is not always one\n * of them and a box a rounding wide lets a history through by a rounding.\n */\nfn reconVarianceBox(samples: array<vec3<f32>, 9>, gamma: f32) -> ReconBox {\n  var s = samples;\n  var box: ReconBox;\n  for (var c = 0u; c < 3u; c = c + 1u) {\n    let first = s[0][c];\n    var same = true;\n    var sum = 0.0;\n    for (var i = 0u; i < 9u; i = i + 1u) {\n      let value = s[i][c];\n      sum = sum + value;\n      if (value != first) { same = false; }\n    }\n    if (same) {\n      box.low[c] = first;\n      box.high[c] = first;\n      continue;\n    }\n    let mean = sum / 9.0;\n    var spread = 0.0;\n    for (var i = 0u; i < 9u; i = i + 1u) {\n      let d = s[i][c] - mean;\n      spread = spread + d * d;\n    }\n    let deviation = sqrt(spread / 9.0);\n    box.low[c] = mean - gamma * deviation;\n    box.high[c] = mean + gamma * deviation;\n  }\n  return box;\n}\n\n/*\n * The history pulled towards the box's centre until it is inside, by one ratio for all three\n * channels \u2014 a clamp per channel would land it on a corner and change its hue, which is coloured\n * fringing on every moving edge. A channel with no extent bounds anything that differs from it\n * infinitely, so such a history collapses onto the centre.\n */\nfn reconClipToBox(history: vec3<f32>, low: vec3<f32>, high: vec3<f32>) -> vec3<f32> {\n  let centre = (low + high) * 0.5;\n  var offset = history - centre;\n  var extent = (high - low) * 0.5;\n  var ratio = 0.0;\n  var infinite = false;\n  for (var c = 0u; c < 3u; c = c + 1u) {\n    if (extent[c] > 1e-7) {\n      ratio = max(ratio, abs(offset[c]) / extent[c]);\n    } else if (abs(offset[c]) > 1e-7) {\n      infinite = true;\n    }\n  }\n  if (!infinite && !(ratio > 1.0)) { return history; }\n  var scale = 0.0;\n  if (!infinite) { scale = 1.0 / ratio; }\n  return centre + offset * scale;\n}\n\nfn reconAccumulate(current: vec3<f32>, history: vec3<f32>, weight: f32, alpha: f32) -> vec3<f32> {\n  let kept = clamp(weight, 0.0, 1.0) * (1.0 - clamp(alpha, 0.0, 1.0));\n  return current * (1.0 - kept) + history * kept;\n}\n\nfn reconCatmullRom(t: f32) -> vec4<f32> {\n  let t2 = t * t;\n  let t3 = t2 * t;\n  return vec4<f32>(\n    -0.5 * t3 + t2 - 0.5 * t,\n    1.5 * t3 - 2.5 * t2 + 1.0,\n    -1.5 * t3 + 2.0 * t2 + 0.5 * t,\n    0.5 * t3 - 0.5 * t2,\n  );\n}\n\n/*\n * Five bilinear taps standing for the sixteen-texel Catmull-Rom: each axis's middle pair folded\n * into one tap placed between them, the corners dropped, the five weights renormalised. It is the\n * five-tap form because the taps are the expensive part \u2014 which is only true while the bilinear is\n * the sampler's, so the production module's accessor is a filtered sample and the check's is the\n * reference's own arithmetic over loaded texels.\n */\nstruct ReconTaps {\n  at0: vec2<f32>,\n  at1: vec2<f32>,\n  at2: vec2<f32>,\n  at3: vec2<f32>,\n  at4: vec2<f32>,\n  weights: array<f32, 5>,\n  total: f32,\n}\n\nfn reconBicubicTaps(x: f32, y: f32) -> ReconTaps {\n  let x1 = floor(x);\n  let y1 = floor(y);\n  let wx = reconCatmullRom(x - x1);\n  let wy = reconCatmullRom(y - y1);\n  let wx12 = wx[1] + wx[2];\n  let wy12 = wy[1] + wy[2];\n  let x12 = x1 + wx[2] / wx12;\n  let y12 = y1 + wy[2] / wy12;\n  var taps: ReconTaps;\n  taps.at0 = vec2<f32>(x12, y1 - 1.0);\n  taps.at1 = vec2<f32>(x1 - 1.0, y12);\n  taps.at2 = vec2<f32>(x12, y12);\n  taps.at3 = vec2<f32>(x1 + 2.0, y12);\n  taps.at4 = vec2<f32>(x12, y1 + 2.0);\n  taps.weights[0] = wx12 * wy[0];\n  taps.weights[1] = wx[0] * wy12;\n  taps.weights[2] = wx12 * wy12;\n  taps.weights[3] = wx[3] * wy12;\n  taps.weights[4] = wx12 * wy[3];\n  taps.total =\n    taps.weights[0] + taps.weights[1] + taps.weights[2] + taps.weights[3] + taps.weights[4];\n  return taps;\n}\n\n/* A colour cannot be negative, and Catmull-Rom's negative lobes undershoot beside a bright edge. */\nfn reconSceneBicubic5(x: f32, y: f32) -> vec3<f32> {\n  let taps = reconBicubicTaps(x, y);\n  var sum = reconSceneBilinear(taps.at0) * taps.weights[0];\n  sum = sum + reconSceneBilinear(taps.at1) * taps.weights[1];\n  sum = sum + reconSceneBilinear(taps.at2) * taps.weights[2];\n  sum = sum + reconSceneBilinear(taps.at3) * taps.weights[3];\n  sum = sum + reconSceneBilinear(taps.at4) * taps.weights[4];\n  return max(sum / taps.total, vec3<f32>(0.0));\n}\n\nfn reconHistoryBicubic5(x: f32, y: f32) -> vec4<f32> {\n  let taps = reconBicubicTaps(x, y);\n  var sum = reconHistoryBilinear(taps.at0) * taps.weights[0];\n  sum = sum + reconHistoryBilinear(taps.at1) * taps.weights[1];\n  sum = sum + reconHistoryBilinear(taps.at2) * taps.weights[2];\n  sum = sum + reconHistoryBilinear(taps.at3) * taps.weights[3];\n  sum = sum + reconHistoryBilinear(taps.at4) * taps.weights[4];\n  return max(sum / taps.total, vec4<f32>(0.0));\n}\n\nstruct ReconWorld {\n  ok: bool,\n  position: vec3<f32>,\n}\n\n/* The world position a clip depth stands for, and nothing where the matrix has no answer there. */\nfn reconWorldFromDepth(m: mat4x4<f32>, u: f32, v: f32, clipDepth: f32) -> ReconWorld {\n  var out: ReconWorld;\n  out.position = vec3<f32>(0.0);\n  out.ok = false;\n  let x = u * 2.0 - 1.0;\n  let y = v * 2.0 - 1.0;\n  let w = m[0][3] * x + m[1][3] * y + m[2][3] * clipDepth + m[3][3];\n  if (!(abs(w) > 1e-12)) { return out; }\n  let p = m * vec4<f32>(x, y, clipDepth, 1.0);\n  out.position = p.xyz / w;\n  out.ok = all(abs(out.position) < vec3<f32>(3.4e38));\n  return out;\n}\n\nstruct ReconNormal {\n  ok: bool,\n  normal: vec3<f32>,\n}\n\n/* Turned to face the eye, so the answer is the same whichever way the target's rows run. */\nfn reconNormalFrom(\n  centre: vec3<f32>,\n  right: vec3<f32>,\n  up: vec3<f32>,\n  eye: vec3<f32>,\n) -> ReconNormal {\n  var out: ReconNormal;\n  out.normal = vec3<f32>(0.0);\n  out.ok = false;\n  let a = right - centre;\n  let b = up - centre;\n  let n = cross(a, b);\n  let length2 = dot(n, n);\n  let scale2 = dot(a, a) * dot(b, b);\n  if (!(length2 > 1e-12 * scale2)) { return out; }\n  let toEye = dot(n, eye - centre);\n  var sign = 1.0;\n  if (toEye < 0.0) { sign = -1.0; }\n  out.normal = n * (sign / sqrt(length2));\n  out.ok = true;\n  return out;\n}\n\nfn reconDisocclusion(\n  currDepth: f32,\n  histDepth: f32,\n  motionLength: f32,\n  normalDot: f32,\n) -> f32 {\n  if (!(currDepth > 0.0) || !(histDepth > 0.0) || !(motionLength >= 0.0)) { return 0.0; }\n  let disagreement = abs(currDepth - histDepth) / currDepth;\n  let tolerance = recon.depthTolerance + recon.motionScale * motionLength;\n  let depth = 1.0 - reconSmoothstep(tolerance, 2.0 * tolerance, disagreement);\n  let normal = reconSmoothstep(recon.normalFloor, recon.normalCeiling, normalDot);\n  return depth * normal;\n}\n\nstruct ReconAt {\n  depth: f32,\n  position: vec3<f32>,\n}\n\n/* A texel's world position at its unjittered uv, and the view depth it stands at, or zero. */\nfn reconWorldAt(previous: bool, x: i32, y: i32) -> ReconAt {\n  let w = i32(recon.renderSize.x);\n  let h = i32(recon.renderSize.y);\n  let tx = reconClampTexel(x, w);\n  let ty = reconClampTexel(y, h);\n  var jitter = recon.jitter;\n  var m = recon.inverseViewProj;\n  var z = reconDepth(tx, ty);\n  if (previous) {\n    jitter = recon.previousJitter;\n    m = recon.previousInverseViewProj;\n    z = reconPreviousDepth(tx, ty);\n  }\n  let u = (f32(tx) + 0.5 - jitter.x) / f32(w);\n  let v = (f32(ty) + 0.5 - jitter.y) / f32(h);\n  var out: ReconAt;\n  out.depth = 0.0;\n  out.position = vec3<f32>(0.0);\n  let world = reconWorldFromDepth(m, u, v, z);\n  if (!world.ok) { return out; }\n  out.position = world.position;\n  /* The view depth is the clip w, which the inverse's w is the reciprocal of. */\n  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];\n  out.depth = 1.0 / cw;\n  return out;\n}\n\n/* The neighbour on the inside of the border, so the edge texels have a normal too. */\nfn reconNormalAt(previous: bool, x: i32, y: i32) -> ReconNormal {\n  var out: ReconNormal;\n  out.normal = vec3<f32>(0.0);\n  out.ok = false;\n  let w = i32(recon.renderSize.x);\n  let h = i32(recon.renderSize.y);\n  let centre = reconWorldAt(previous, x, y);\n  if (!(centre.depth > 0.0)) { return out; }\n  var dx = -1;\n  if (x + 1 < w) { dx = 1; }\n  var dy = -1;\n  if (y + 1 < h) { dy = 1; }\n  let right = reconWorldAt(previous, x + dx, y);\n  if (!(right.depth > 0.0)) { return out; }\n  let up = reconWorldAt(previous, x, y + dy);\n  if (!(up.depth > 0.0)) { return out; }\n  var eye = recon.eye.xyz;\n  if (previous) { eye = recon.previousEye.xyz; }\n  return reconNormalFrom(centre.position, right.position, up.position, eye);\n}\n\nstruct ReconHistory {\n  weight: f32,\n  colour: vec4<f32>,\n}\n\n/*\n * The weight a pixel's history still deserves: none on the first frame, none where the surface was\n * behind last frame's eye or off its picture, and otherwise what it gathered, scaled by whether it\n * is the same surface.\n */\nfn reconHistoryWeight(u: f32, v: f32, dx: i32, dy: i32) -> ReconHistory {\n  var out: ReconHistory;\n  out.weight = 0.0;\n  out.colour = vec4<f32>(0.0);\n  if (recon.hasHistory == 0u) { return out; }\n  let rw = f32(recon.renderSize.x);\n  let rh = f32(recon.renderSize.y);\n  let motion = reconMotion(dx, dy);\n  var mu = 0.0;\n  var mv = 0.0;\n  var expected = 0.0;\n  if (motion.w > 0.5) {\n    mu = motion.x;\n    mv = motion.y;\n    expected = motion.z;\n  } else {\n    let here = reconWorldAt(false, dx, dy);\n    if (!(here.depth > 0.0)) { return out; }\n    let clip = recon.previousViewProj * vec4<f32>(here.position, 1.0);\n    /*\n     * A surface behind last frame's eye has a w that is not positive: the disocclusion trusts no\n     * such depth, so it needs no refusal of its own here.\n     */\n    expected = clip.w;\n    let du = (f32(dx) + 0.5 - recon.jitter.x) / rw;\n    let dv = (f32(dy) + 0.5 - recon.jitter.y) / rh;\n    mu = (clip.x / expected) * 0.5 + 0.5 - du;\n    mv = (clip.y / expected) * 0.5 + 0.5 - dv;\n  }\n\n  let pu = u + mu;\n  let pv = v + mv;\n  if (!(pu >= 0.0 && pu <= 1.0 && pv >= 0.0 && pv <= 1.0)) { return out; }\n  out.colour = reconHistoryBicubic5(\n    pu * f32(recon.outputSize.x) - 0.5,\n    pv * f32(recon.outputSize.y) - 0.5,\n  );\n  let px = reconClampTexel(i32(reconRound(pu * rw + recon.previousJitter.x - 0.5)), i32(rw));\n  let py = reconClampTexel(i32(reconRound(pv * rh + recon.previousJitter.y - 0.5)), i32(rh));\n  let held = reconWorldAt(true, px, py).depth;\n  var normalDot = 1.0;\n  let here = reconNormalAt(false, dx, dy);\n  let there = reconNormalAt(true, px, py);\n  if (here.ok && there.ok) { normalDot = dot(here.normal, there.normal); }\n  let trust = reconDisocclusion(expected, held, length(vec2<f32>(mu, mv)), normalDot);\n  out.weight = out.colour.w * trust;\n  return out;\n}\n\n/* One output pixel: the history's next colour, before sharpening, and the weight it has gathered. */\nfn reconResolvePixel(ox: i32, oy: i32) -> vec4<f32> {\n  let rw = i32(recon.renderSize.x);\n  let rh = i32(recon.renderSize.y);\n  let ow = i32(recon.outputSize.x);\n  let oh = i32(recon.outputSize.y);\n  let u = (f32(ox) + 0.5) / f32(ow);\n  let v = (f32(oy) + 0.5) / f32(oh);\n  let jx = recon.jitter.x;\n  let jy = recon.jitter.y;\n\n  /* Where this frame observed the pixel, and the render read there for the gaps. */\n  let rx = u * f32(rw) + jx - 0.5;\n  let ry = v * f32(rh) + jy - 0.5;\n  let sample = reconSceneBicubic5(rx, ry);\n  let nx = reconClampTexel(i32(reconRound(rx)), rw);\n  let ny = reconClampTexel(i32(reconRound(ry)), rh);\n\n  /* Each texel around: its weight, its colour in the box, and its depth. */\n  var nearest = reconDepth(nx, ny);\n  var dx = nx;\n  var dy = ny;\n  var gathered = 0.0;\n  var accum = vec3<f32>(0.0);\n  var neighbours: array<vec3<f32>, 9>;\n  for (var j = -1; j <= 1; j = j + 1) {\n    for (var i = -1; i <= 1; i = i + 1) {\n      let tx = reconClampTexel(nx + i, rw);\n      let ty = reconClampTexel(ny + j, rh);\n      let colour = reconScene(tx, ty);\n      let weight = reconWeightAt(\n        ((f32(tx) + 0.5 - jx) / f32(rw)) * f32(ow) - (f32(ox) + 0.5),\n        ((f32(ty) + 0.5 - jy) / f32(rh)) * f32(oh) - (f32(oy) + 0.5),\n      );\n      gathered = gathered + weight;\n      accum = accum + colour * weight;\n      neighbours[(j + 1) * 3 + (i + 1)] = reconToYCoCg(colour);\n      let z = reconDepth(tx, ty);\n      if (z < nearest) {\n        nearest = z;\n        dx = tx;\n        dy = ty;\n      }\n    }\n  }\n  let box = reconVarianceBox(neighbours, recon.clampGamma);\n  accum = accum / gathered;\n\n  /* The history, and the weight it still deserves; a tenth of each frame is always new. */\n  let cap = (1.0 - recon.alpha) / recon.alpha;\n  let history = reconHistoryWeight(u, v, dx, dy);\n  let kept = min(cap, history.weight);\n\n  let total = kept + gathered;\n  var mixed = accum;\n  if (kept > 0.0) {\n    let clipped = reconClipToBox(reconToYCoCg(history.colour.xyz), box.low, box.high);\n    mixed = reconAccumulate(accum, reconFromYCoCg(clipped), 1.0, gathered / total);\n  }\n  let known = min(1.0, total / RECON_CONFIDENT_WEIGHT);\n  return vec4<f32>(sample * (1.0 - known) + mixed * known, total);\n}\n\n/*\n * The centre pushed away from its four neighbours' mean, and held inside the range of the five \u2014\n * the halo a plain unsharp mask draws beside every edge is a value outside that range.\n */\nfn reconSharpenAt(ox: i32, oy: i32) -> vec3<f32> {\n  let ow = i32(recon.outputSize.x);\n  let oh = i32(recon.outputSize.y);\n  let centre = reconHistory(reconClampTexel(ox, ow), reconClampTexel(oy, oh)).xyz;\n  var offsets = array<vec2<i32>, 4>(\n    vec2<i32>(-1, 0),\n    vec2<i32>(1, 0),\n    vec2<i32>(0, -1),\n    vec2<i32>(0, 1),\n  );\n  var low = centre;\n  var high = centre;\n  var sum = vec3<f32>(0.0);\n  for (var n = 0; n < 4; n = n + 1) {\n    let at = offsets[n];\n    let value = reconHistory(\n      reconClampTexel(ox + at.x, ow),\n      reconClampTexel(oy + at.y, oh),\n    ).xyz;\n    sum = sum + value;\n    low = min(low, value);\n    high = max(high, value);\n  }\n  let pushed = centre + recon.sharpenAmount * (centre - sum / 4.0);\n  return min(high, max(low, pushed));\n}\n";
+export declare const RECON_RESOLVE_CORE_WGSL = "\nconst RECON_SAMPLE_SPREAD: f32 = 0.47;\nconst RECON_CONFIDENT_WEIGHT: f32 = 1.0;\nconst RECON_PLANAR_FROM: f32 = 0.25;\nconst RECON_PLANAR_TO: f32 = 0.5;\n\nfn reconClampTexel(value: i32, size: i32) -> i32 {\n  return clamp(value, 0, size - 1);\n}\n\n/* JavaScript's Math.round, which is not WGSL's round: a half goes up, not to even. */\nfn reconRound(value: f32) -> f32 {\n  return floor(value + 0.5);\n}\n\n/* Written out rather than the built-in, whose result is undefined where the edges are equal. */\nfn reconSmoothstep(edge0: f32, edge1: f32, x: f32) -> f32 {\n  let t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n  return t * t * (3.0 - 2.0 * t);\n}\n\nfn reconWeightAt(dx: f32, dy: f32) -> f32 {\n  return exp(-(dx * dx + dy * dy) / (2.0 * RECON_SAMPLE_SPREAD * RECON_SAMPLE_SPREAD));\n}\n\nfn reconToYCoCg(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(\n    c.r * 0.25 + c.g * 0.5 + c.b * 0.25,\n    c.r * 0.5 - c.b * 0.5,\n    -c.r * 0.25 + c.g * 0.5 - c.b * 0.25,\n  );\n}\n\nfn reconFromYCoCg(c: vec3<f32>) -> vec3<f32> {\n  let base = c.x - c.z;\n  return vec3<f32>(base + c.y, c.x + c.z, base - c.y);\n}\n\nstruct ReconBox {\n  low: vec3<f32>,\n  high: vec3<f32>,\n}\n\n/*\n * Each channel's mean plus or minus gamma of its standard deviation \u2014 and a channel whose nine\n * samples all agree is that value exactly, because a mean of nine equal floats is not always one\n * of them and a box a rounding wide lets a history through by a rounding.\n */\nfn reconVarianceBox(samples: array<vec3<f32>, 9>, gamma: f32) -> ReconBox {\n  var s = samples;\n  var box: ReconBox;\n  for (var c = 0u; c < 3u; c = c + 1u) {\n    let first = s[0][c];\n    var same = true;\n    var sum = 0.0;\n    for (var i = 0u; i < 9u; i = i + 1u) {\n      let value = s[i][c];\n      sum = sum + value;\n      if (value != first) { same = false; }\n    }\n    if (same) {\n      box.low[c] = first;\n      box.high[c] = first;\n      continue;\n    }\n    let mean = sum / 9.0;\n    var spread = 0.0;\n    for (var i = 0u; i < 9u; i = i + 1u) {\n      let d = s[i][c] - mean;\n      spread = spread + d * d;\n    }\n    let deviation = sqrt(spread / 9.0);\n    box.low[c] = mean - gamma * deviation;\n    box.high[c] = mean + gamma * deviation;\n  }\n  return box;\n}\n\n/*\n * The history pulled towards the box's centre until it is inside, by one ratio for all three\n * channels \u2014 a clamp per channel would land it on a corner and change its hue, which is coloured\n * fringing on every moving edge. A channel with no extent bounds anything that differs from it\n * infinitely, so such a history collapses onto the centre.\n */\nfn reconClipToBox(history: vec3<f32>, low: vec3<f32>, high: vec3<f32>) -> vec3<f32> {\n  let centre = (low + high) * 0.5;\n  var offset = history - centre;\n  var extent = (high - low) * 0.5;\n  var ratio = 0.0;\n  var infinite = false;\n  for (var c = 0u; c < 3u; c = c + 1u) {\n    if (extent[c] > 1e-7) {\n      ratio = max(ratio, abs(offset[c]) / extent[c]);\n    } else if (abs(offset[c]) > 1e-7) {\n      infinite = true;\n    }\n  }\n  if (!infinite && !(ratio > 1.0)) { return history; }\n  var scale = 0.0;\n  if (!infinite) { scale = 1.0 / ratio; }\n  return centre + offset * scale;\n}\n\nfn reconAccumulate(current: vec3<f32>, history: vec3<f32>, weight: f32, alpha: f32) -> vec3<f32> {\n  let kept = clamp(weight, 0.0, 1.0) * (1.0 - clamp(alpha, 0.0, 1.0));\n  return current * (1.0 - kept) + history * kept;\n}\n\nfn reconCatmullRom(t: f32) -> vec4<f32> {\n  let t2 = t * t;\n  let t3 = t2 * t;\n  return vec4<f32>(\n    -0.5 * t3 + t2 - 0.5 * t,\n    1.5 * t3 - 2.5 * t2 + 1.0,\n    -1.5 * t3 + 2.0 * t2 + 0.5 * t,\n    0.5 * t3 - 0.5 * t2,\n  );\n}\n\n/*\n * Five bilinear taps standing for the sixteen-texel Catmull-Rom: each axis's middle pair folded\n * into one tap placed between them, the corners dropped, the five weights renormalised. It is the\n * five-tap form because the taps are the expensive part \u2014 which is only true while the bilinear is\n * the sampler's, so the production module's accessor is a filtered sample and the check's is the\n * reference's own arithmetic over loaded texels.\n */\nstruct ReconTaps {\n  at0: vec2<f32>,\n  at1: vec2<f32>,\n  at2: vec2<f32>,\n  at3: vec2<f32>,\n  at4: vec2<f32>,\n  weights: array<f32, 5>,\n  total: f32,\n}\n\nfn reconBicubicTaps(x: f32, y: f32) -> ReconTaps {\n  let x1 = floor(x);\n  let y1 = floor(y);\n  let wx = reconCatmullRom(x - x1);\n  let wy = reconCatmullRom(y - y1);\n  let wx12 = wx[1] + wx[2];\n  let wy12 = wy[1] + wy[2];\n  let x12 = x1 + wx[2] / wx12;\n  let y12 = y1 + wy[2] / wy12;\n  var taps: ReconTaps;\n  taps.at0 = vec2<f32>(x12, y1 - 1.0);\n  taps.at1 = vec2<f32>(x1 - 1.0, y12);\n  taps.at2 = vec2<f32>(x12, y12);\n  taps.at3 = vec2<f32>(x1 + 2.0, y12);\n  taps.at4 = vec2<f32>(x12, y1 + 2.0);\n  taps.weights[0] = wx12 * wy[0];\n  taps.weights[1] = wx[0] * wy12;\n  taps.weights[2] = wx12 * wy12;\n  taps.weights[3] = wx[3] * wy12;\n  taps.weights[4] = wx12 * wy[3];\n  taps.total =\n    taps.weights[0] + taps.weights[1] + taps.weights[2] + taps.weights[3] + taps.weights[4];\n  return taps;\n}\n\n/* A colour cannot be negative, and Catmull-Rom's negative lobes undershoot beside a bright edge. */\nfn reconSceneBicubic5(x: f32, y: f32) -> vec3<f32> {\n  let taps = reconBicubicTaps(x, y);\n  var sum = reconSceneBilinear(taps.at0) * taps.weights[0];\n  sum = sum + reconSceneBilinear(taps.at1) * taps.weights[1];\n  sum = sum + reconSceneBilinear(taps.at2) * taps.weights[2];\n  sum = sum + reconSceneBilinear(taps.at3) * taps.weights[3];\n  sum = sum + reconSceneBilinear(taps.at4) * taps.weights[4];\n  return max(sum / taps.total, vec3<f32>(0.0));\n}\n\nfn reconHistoryBicubic5(x: f32, y: f32) -> vec4<f32> {\n  let taps = reconBicubicTaps(x, y);\n  var sum = reconHistoryBilinear(taps.at0) * taps.weights[0];\n  sum = sum + reconHistoryBilinear(taps.at1) * taps.weights[1];\n  sum = sum + reconHistoryBilinear(taps.at2) * taps.weights[2];\n  sum = sum + reconHistoryBilinear(taps.at3) * taps.weights[3];\n  sum = sum + reconHistoryBilinear(taps.at4) * taps.weights[4];\n  return max(sum / taps.total, vec4<f32>(0.0));\n}\n\nstruct ReconWorld {\n  ok: bool,\n  position: vec3<f32>,\n}\n\n/* The world position a clip depth stands for, and nothing where the matrix has no answer there. */\nfn reconWorldFromDepth(m: mat4x4<f32>, u: f32, v: f32, clipDepth: f32) -> ReconWorld {\n  var out: ReconWorld;\n  out.position = vec3<f32>(0.0);\n  out.ok = false;\n  let x = u * 2.0 - 1.0;\n  let y = v * 2.0 - 1.0;\n  let w = m[0][3] * x + m[1][3] * y + m[2][3] * clipDepth + m[3][3];\n  if (!(abs(w) > 1e-12)) { return out; }\n  let p = m * vec4<f32>(x, y, clipDepth, 1.0);\n  out.position = p.xyz / w;\n  out.ok = all(abs(out.position) < vec3<f32>(3.4e38));\n  return out;\n}\n\nstruct ReconNormal {\n  ok: bool,\n  normal: vec3<f32>,\n}\n\n/* Turned to face the eye, so the answer is the same whichever way the target's rows run. */\nfn reconNormalFrom(\n  centre: vec3<f32>,\n  right: vec3<f32>,\n  up: vec3<f32>,\n  eye: vec3<f32>,\n) -> ReconNormal {\n  var out: ReconNormal;\n  out.normal = vec3<f32>(0.0);\n  out.ok = false;\n  let a = right - centre;\n  let b = up - centre;\n  let n = cross(a, b);\n  let length2 = dot(n, n);\n  let scale2 = dot(a, a) * dot(b, b);\n  if (!(length2 > 1e-12 * scale2)) { return out; }\n  let toEye = dot(n, eye - centre);\n  var sign = 1.0;\n  if (toEye < 0.0) { sign = -1.0; }\n  out.normal = n * (sign / sqrt(length2));\n  out.ok = true;\n  return out;\n}\n\nfn reconDisocclusion(\n  currDepth: f32,\n  histDepth: f32,\n  motionLength: f32,\n  normalDot: f32,\n  slope: f32,\n) -> f32 {\n  if (!(currDepth > 0.0) || !(histDepth > 0.0) || !(motionLength >= 0.0)) { return 0.0; }\n  let disagreement = abs(currDepth - histDepth) / currDepth;\n  let tolerance = recon.depthTolerance + recon.motionScale * motionLength + slope;\n  let depth = 1.0 - reconSmoothstep(tolerance, 2.0 * tolerance, disagreement);\n  let normal = reconSmoothstep(recon.normalFloor, recon.normalCeiling, normalDot);\n  return depth * normal;\n}\n\nstruct ReconAt {\n  depth: f32,\n  position: vec3<f32>,\n}\n\n/* A texel's world position at its unjittered uv, and the view depth it stands at, or zero. */\nfn reconWorldAt(previous: bool, x: i32, y: i32) -> ReconAt {\n  let w = i32(recon.renderSize.x);\n  let h = i32(recon.renderSize.y);\n  let tx = reconClampTexel(x, w);\n  let ty = reconClampTexel(y, h);\n  var jitter = recon.jitter;\n  var m = recon.inverseViewProj;\n  var z = reconDepth(tx, ty);\n  if (previous) {\n    jitter = recon.previousJitter;\n    m = recon.previousInverseViewProj;\n    z = reconPreviousDepth(tx, ty);\n  }\n  let u = (f32(tx) + 0.5 - jitter.x) / f32(w);\n  let v = (f32(ty) + 0.5 - jitter.y) / f32(h);\n  var out: ReconAt;\n  out.depth = 0.0;\n  out.position = vec3<f32>(0.0);\n  let world = reconWorldFromDepth(m, u, v, z);\n  if (!world.ok) { return out; }\n  out.position = world.position;\n  /* The view depth is the clip w, which the inverse's w is the reciprocal of. */\n  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];\n  out.depth = 1.0 / cw;\n  return out;\n}\n\n/* The neighbour on the inside of the border, so the edge texels have a normal too. */\nfn reconNormalAt(previous: bool, x: i32, y: i32) -> ReconNormal {\n  var out: ReconNormal;\n  out.normal = vec3<f32>(0.0);\n  out.ok = false;\n  let w = i32(recon.renderSize.x);\n  let h = i32(recon.renderSize.y);\n  let centre = reconWorldAt(previous, x, y);\n  if (!(centre.depth > 0.0)) { return out; }\n  var dx = -1;\n  if (x + 1 < w) { dx = 1; }\n  var dy = -1;\n  if (y + 1 < h) { dy = 1; }\n  let right = reconWorldAt(previous, x + dx, y);\n  if (!(right.depth > 0.0)) { return out; }\n  let up = reconWorldAt(previous, x, y + dy);\n  if (!(up.depth > 0.0)) { return out; }\n  var eye = recon.eye.xyz;\n  if (previous) { eye = recon.previousEye.xyz; }\n  return reconNormalFrom(centre.position, right.position, up.position, eye);\n}\n\n/* resolve.ts's viewDepthAt. */\nfn reconViewDepthAt(previous: bool, x: i32, y: i32) -> f32 {\n  let w = i32(recon.renderSize.x);\n  let h = i32(recon.renderSize.y);\n  if (x < 0 || y < 0 || x >= w || y >= h) { return 0.0; }\n  var jitter = recon.jitter;\n  var m = recon.inverseViewProj;\n  var z = 0.0;\n  if (previous) {\n    jitter = recon.previousJitter;\n    m = recon.previousInverseViewProj;\n    z = reconPreviousDepth(x, y);\n  } else {\n    z = reconDepth(x, y);\n  }\n  let u = (f32(x) + 0.5 - jitter.x) / f32(w);\n  let v = (f32(y) + 0.5 - jitter.y) / f32(h);\n  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];\n  if (!(abs(cw) > 1e-12)) { return 0.0; }\n  return 1.0 / cw;\n}\n\n/* disocclusion.ts's planarity. */\nfn reconPlanarity(before: f32, centre: f32, after: f32) -> f32 {\n  if (!(before > 0.0) || !(centre > 0.0) || !(after > 0.0)) { return 1.0; }\n  let a = 1.0 / after - 1.0 / centre;\n  let b = 1.0 / before - 1.0 / centre;\n  let spread = abs(a) + abs(b);\n  if (!(spread > 0.0)) { return 1.0; }\n  return 1.0 - reconSmoothstep(RECON_PLANAR_FROM, RECON_PLANAR_TO, abs(a + b) / spread);\n}\n\n/* disocclusion.ts's surfaceSlope. */\nfn reconSurfaceSlope(before: f32, centre: f32, after: f32) -> f32 {\n  let hasAfter = after > 0.0;\n  let hasBefore = before > 0.0;\n  if (!hasAfter) {\n    if (!hasBefore) { return 0.0; }\n    return abs(before - centre) / centre;\n  }\n  if (!hasBefore) { return abs(after - centre) / centre; }\n  let a = after - centre;\n  let b = before - centre;\n  if (a * b > 0.0) { return 0.0; }\n  return min(abs(a), abs(b)) / centre;\n}\n\nstruct ReconSurface {\n  planar: f32,\n  slope: f32,\n}\n\n/* resolve.ts's surfaceAt. */\nfn reconSurfaceAt(previous: bool, x: i32, y: i32, centre: f32) -> ReconSurface {\n  var out: ReconSurface;\n  out.planar = 1.0;\n  out.slope = 0.0;\n  for (var axis = 0; axis < 2; axis = axis + 1) {\n    let ax = 1 - axis;\n    let ay = axis;\n    let after = reconViewDepthAt(previous, x + ax, y + ay);\n    let before = reconViewDepthAt(previous, x - ax, y - ay);\n    out.planar = out.planar * reconPlanarity(before, centre, after);\n    out.slope = max(out.slope, reconSurfaceSlope(before, centre, after));\n  }\n  return out;\n}\n\nstruct ReconHistory {\n  weight: f32,\n  colour: vec4<f32>,\n}\n\n/*\n * The weight a pixel's history still deserves: none on the first frame, none where the surface was\n * behind last frame's eye or off its picture, and otherwise what it gathered, scaled by whether it\n * is the same surface.\n */\nfn reconHistoryWeight(u: f32, v: f32, dx: i32, dy: i32) -> ReconHistory {\n  var out: ReconHistory;\n  out.weight = 0.0;\n  out.colour = vec4<f32>(0.0);\n  if (recon.hasHistory == 0u) { return out; }\n  let rw = f32(recon.renderSize.x);\n  let rh = f32(recon.renderSize.y);\n  let motion = reconMotion(dx, dy);\n  var mu = 0.0;\n  var mv = 0.0;\n  var expected = 0.0;\n  if (motion.w > 0.5) {\n    mu = motion.x;\n    mv = motion.y;\n    expected = motion.z;\n  } else {\n    let here = reconWorldAt(false, dx, dy);\n    if (!(here.depth > 0.0)) { return out; }\n    let clip = recon.previousViewProj * vec4<f32>(here.position, 1.0);\n    /*\n     * A surface behind last frame's eye has a w that is not positive: the disocclusion trusts no\n     * such depth, so it needs no refusal of its own here.\n     */\n    expected = clip.w;\n    let du = (f32(dx) + 0.5 - recon.jitter.x) / rw;\n    let dv = (f32(dy) + 0.5 - recon.jitter.y) / rh;\n    mu = (clip.x / expected) * 0.5 + 0.5 - du;\n    mv = (clip.y / expected) * 0.5 + 0.5 - dv;\n  }\n\n  let pu = u + mu;\n  let pv = v + mv;\n  if (!(pu >= 0.0 && pu <= 1.0 && pv >= 0.0 && pv <= 1.0)) { return out; }\n  out.colour = reconHistoryBicubic5(\n    pu * f32(recon.outputSize.x) - 0.5,\n    pv * f32(recon.outputSize.y) - 0.5,\n  );\n  /* Last frame's depth, searched around where the dilated texel was: see resolve.ts. */\n  let su = (f32(dx) + 0.5 - recon.jitter.x) / rw + mu;\n  let sv = (f32(dy) + 0.5 - recon.jitter.y) / rh + mv;\n  let cx = reconClampTexel(i32(reconRound(su * rw + recon.previousJitter.x - 0.5)), i32(rw));\n  let cy = reconClampTexel(i32(reconRound(sv * rh + recon.previousJitter.y - 0.5)), i32(rh));\n  var held = reconViewDepthAt(true, cx, cy);\n  var px = cx;\n  var py = cy;\n  if (!(held > 0.0 && abs(held - expected) <= recon.depthTolerance * expected)) {\n    held = 0.0;\n    var nearest = 3.4e38;\n    for (var j = -1; j <= 1; j = j + 1) {\n      for (var i = -1; i <= 1; i = i + 1) {\n        let tx = reconClampTexel(cx + i, i32(rw));\n        let ty = reconClampTexel(cy + j, i32(rh));\n        let depth = reconViewDepthAt(true, tx, ty);\n        if (!(depth > 0.0)) { continue; }\n        let off = abs(depth - expected);\n        if (off < nearest) {\n          nearest = off;\n          held = depth;\n          px = tx;\n          py = ty;\n        }\n      }\n    }\n  }\n\n  let here = reconSurfaceAt(false, dx, dy, reconViewDepthAt(false, dx, dy));\n  var planar = here.planar;\n  if (planar > 0.0) { planar = planar * reconSurfaceAt(true, px, py, held).planar; }\n  var normalDot = 1.0;\n  if (planar > 0.0) {\n    let hereNormal = reconNormalAt(false, dx, dy);\n    let thereNormal = reconNormalAt(true, px, py);\n    if (hereNormal.ok && thereNormal.ok) {\n      normalDot = 1.0 - planar * (1.0 - dot(hereNormal.normal, thereNormal.normal));\n    }\n  }\n  let trust = reconDisocclusion(expected, held, length(vec2<f32>(mu, mv)), normalDot, here.slope);\n  out.weight = out.colour.w * trust;\n  return out;\n}\n\n/* One output pixel: the history's next colour, before sharpening, and the weight it has gathered. */\nfn reconResolvePixel(ox: i32, oy: i32) -> vec4<f32> {\n  let rw = i32(recon.renderSize.x);\n  let rh = i32(recon.renderSize.y);\n  let ow = i32(recon.outputSize.x);\n  let oh = i32(recon.outputSize.y);\n  let u = (f32(ox) + 0.5) / f32(ow);\n  let v = (f32(oy) + 0.5) / f32(oh);\n  let jx = recon.jitter.x;\n  let jy = recon.jitter.y;\n\n  /* Where this frame observed the pixel, and the render read there for the gaps. */\n  let rx = u * f32(rw) + jx - 0.5;\n  let ry = v * f32(rh) + jy - 0.5;\n  let sample = reconSceneBicubic5(rx, ry);\n  let nx = reconClampTexel(i32(reconRound(rx)), rw);\n  let ny = reconClampTexel(i32(reconRound(ry)), rh);\n\n  /* Each texel around: its weight, its colour in the box, and its depth. */\n  var nearest = reconDepth(nx, ny);\n  var dx = nx;\n  var dy = ny;\n  var gathered = 0.0;\n  var accum = vec3<f32>(0.0);\n  var neighbours: array<vec3<f32>, 9>;\n  for (var j = -1; j <= 1; j = j + 1) {\n    for (var i = -1; i <= 1; i = i + 1) {\n      let tx = reconClampTexel(nx + i, rw);\n      let ty = reconClampTexel(ny + j, rh);\n      let colour = reconScene(tx, ty);\n      let weight = reconWeightAt(\n        ((f32(tx) + 0.5 - jx) / f32(rw)) * f32(ow) - (f32(ox) + 0.5),\n        ((f32(ty) + 0.5 - jy) / f32(rh)) * f32(oh) - (f32(oy) + 0.5),\n      );\n      gathered = gathered + weight;\n      accum = accum + colour * weight;\n      neighbours[(j + 1) * 3 + (i + 1)] = reconToYCoCg(colour);\n      let z = reconDepth(tx, ty);\n      if (z < nearest) {\n        nearest = z;\n        dx = tx;\n        dy = ty;\n      }\n    }\n  }\n  let box = reconVarianceBox(neighbours, recon.clampGamma);\n  accum = accum / gathered;\n\n  /* The history, and the weight it still deserves; a tenth of each frame is always new. */\n  let cap = (1.0 - recon.alpha) / recon.alpha;\n  let history = reconHistoryWeight(u, v, dx, dy);\n  let kept = min(cap, history.weight);\n\n  let total = kept + gathered;\n  var mixed = accum;\n  if (kept > 0.0) {\n    let clipped = reconClipToBox(reconToYCoCg(history.colour.xyz), box.low, box.high);\n    mixed = reconAccumulate(accum, reconFromYCoCg(clipped), 1.0, gathered / total);\n  }\n  let known = min(1.0, total / RECON_CONFIDENT_WEIGHT);\n  return vec4<f32>(sample * (1.0 - known) + mixed * known, total);\n}\n\n/*\n * The centre pushed away from its four neighbours' mean, and held inside the range of the five \u2014\n * the halo a plain unsharp mask draws beside every edge is a value outside that range.\n */\nfn reconSharpenAt(ox: i32, oy: i32) -> vec3<f32> {\n  let ow = i32(recon.outputSize.x);\n  let oh = i32(recon.outputSize.y);\n  let centre = reconHistory(reconClampTexel(ox, ow), reconClampTexel(oy, oh)).xyz;\n  var offsets = array<vec2<i32>, 4>(\n    vec2<i32>(-1, 0),\n    vec2<i32>(1, 0),\n    vec2<i32>(0, -1),\n    vec2<i32>(0, 1),\n  );\n  var low = centre;\n  var high = centre;\n  var sum = vec3<f32>(0.0);\n  for (var n = 0; n < 4; n = n + 1) {\n    let at = offsets[n];\n    let value = reconHistory(\n      reconClampTexel(ox + at.x, ow),\n      reconClampTexel(oy + at.y, oh),\n    ).xyz;\n    sum = sum + value;\n    low = min(low, value);\n    high = max(high, value);\n  }\n  let pushed = centre + recon.sharpenAmount * (centre - sum / 4.0);\n  return min(high, max(low, pushed));\n}\n";
 /**
  * The parity module: the core over plain float textures written in the reference's own row order,
  * doing its own bilinear so the comparison is arithmetic rather than a tolerance on the device's

package/dist/render/shaders/recon/resolve.wgsl.js

@@ -39,6 +39,7 @@
  * and the uniform `recon: ReconParams`, whose struct this module declares.
  */
 import { wgslSceneDepthToNdc } from '../../depthConvention.js';
+import { PLANAR_FROM, PLANAR_TO } from '../../recon/disocclusion.js';
 /**
  * The parameters one resolve reads, as `ResolveFrame` minus its images.
  *
@@ -91,6 +92,8 @@ export const RECON_HISTORY_FORMAT = '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);
@@ -322,10 +325,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;
@@ -386,6 +390,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>,
@@ -433,14 +505,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;
 }