@driftengine/core 4.4.1 → 4.4.2

package/dist/render/recon/disocclusion.js

@@ -12,10 +12,15 @@
  * a different part of a texel than the one it stands for, which at a grazing angle is a different
  * depth; the tolerance grows with the motion's length.
  *
+ * **And in proportion to the surface's own slope.** A new jitter samples a surface somewhere else, so
+ * on one turned from the eye two frames' samples of it differ by up to a texel's worth of its depth
+ * with nothing moved. `surfaceSlope` measures that step on the surface's own side of any silhouette.
+ *
  * **Normals, for the case depth cannot see.** A leaf's two sides are at one depth, and the history of
  * the front is not the back. The forward frame has no normal buffer, so both normals come from their
  * frame's depth — `worldPositionFromDepth` and `normalFromPositions` — in world space, where the two
- * frames agree.
+ * frames agree. **A normal differenced across an edge is not a normal**, so the caller weighs each by
+ * `planarity`: at an edge, a sliver, or anything finer than a texel the depth test decides alone.
  *
  * **Continuous in every input**, because a step is a line on screen along which the history is kept on
  * one frame and dropped on the next: every threshold is a smoothstep, never a comparison.
@@ -37,19 +42,66 @@ function smoothstep(edge0, edge1, x) {
     const t = Math.min(1, Math.max(0, (x - edge0) / (edge1 - edge0)));
     return t * t * (3 - 2 * t);
 }
+/**
+ * The band over which three texels stop being one plane: how far their two steps in inverse depth
+ * fail to cancel, as a share of the two together. None of it is a plane at any angle; all of it is an
+ * edge — one side steps, the other does not — or a sliver, both stepping the same way.
+ *
+ * **A share and not a size**, which is the lesson of the rods in `resolve.test.ts`: a part a
+ * hundredth of the depth in front of a wall passes the depth test, and a normal differenced across it
+ * still leans by its height over a texel's width — nearly edge-on where texels are small. What would
+ * make this wrong is a curved surface judged at its apex, where both steps lean one way and the
+ * normal is sound; there it only gives the normals less say, which the depth test does not need.
+ */
+export const PLANAR_FROM = 0.25;
+export const PLANAR_TO = 0.5;
+/**
+ * How sure it is that `centre` and its neighbours either side along one axis lie on one plane, one to
+ * zero. Inverse depth is affine across a plane on screen, so a plane's two steps cancel whatever its
+ * angle. One where a neighbour is missing — zero, off the picture or undrawn — or where there is no
+ * step to compare: nothing to judge by, so a normal keeps the say it always had.
+ */
+export function planarity(before, centre, after) {
+    if (!(before > 0) || !(centre > 0) || !(after > 0))
+        return 1;
+    const a = 1 / after - 1 / centre;
+    const b = 1 / before - 1 / centre;
+    const spread = Math.abs(a) + Math.abs(b);
+    if (!(spread > 0))
+        return 1;
+    return 1 - smoothstep(PLANAR_FROM, PLANAR_TO, Math.abs(a + b) / spread);
+}
+/**
+ * How far a surface's depth moves across one texel along an axis, relative to the depth: the smaller
+ * of the steps to its two neighbours, because beside a silhouette one of them is the surface behind.
+ * Zero at a sliver — nearer or farther than both, so each step is to another surface — and one
+ * neighbour's step where only one is there.
+ */
+export function surfaceSlope(before, centre, after) {
+    const a = after > 0 ? after - centre : Number.NaN;
+    const b = before > 0 ? before - centre : Number.NaN;
+    if (Number.isNaN(a))
+        return Number.isNaN(b) ? 0 : Math.abs(b) / centre;
+    if (Number.isNaN(b))
+        return Math.abs(a) / centre;
+    if (a * b > 0)
+        return 0;
+    return Math.min(Math.abs(a), Math.abs(b)) / centre;
+}
 /**
  * One where the history is trustworthy, zero where it is not, and continuous between.
  *
  * `currDepth` is the view depth this surface should have had last frame; `histDepth` the view depth
  * last frame held where it lands, or zero where it landed off the screen; `motionLength` the motion's
- * length in uv; `normalDot` the cosine between the two frames' world normals there.
+ * length in uv; `normalDot` the cosine between the two frames' world normals there; `slope` the
+ * surface's `surfaceSlope`, which widens the tolerance one for one.
  */
-export function disocclusionWeight(currDepth, histDepth, motionLength, normalDot, params) {
+export function disocclusionWeight(currDepth, histDepth, motionLength, normalDot, params, slope = 0) {
     if (!(currDepth > 0) || !(histDepth > 0) || !(motionLength >= 0) || Number.isNaN(normalDot)) {
         return 0;
     }
     const disagreement = Math.abs(currDepth - histDepth) / currDepth;
-    const tolerance = params.depthTolerance + params.motionScale * motionLength;
+    const tolerance = params.depthTolerance + params.motionScale * motionLength + slope;
     const depth = 1 - smoothstep(tolerance, 2 * tolerance, disagreement);
     const normal = smoothstep(params.normalFloor, params.normalCeiling, normalDot);
     return depth * normal;

package/dist/render/recon/resolve.js

@@ -21,8 +21,10 @@
  *    previous view depth in its third channel; otherwise it is the camera's, through the surface's
  *    world position.
  * 4. Where the surface was is read from the history — its colour and the weight it had gathered — and
- *    last frame's depth there says whether it is the same surface; the two frames' normals, from their
- *    depths, catch thin geometry. The disocclusion scales the history's weight.
+ *    last frame's depth says whether it is the same surface: the nearest of the nine texels around
+ *    where the dilated texel was, forgiven its own slope across a texel. The two frames' normals, from
+ *    their depths, catch thin geometry, each with the say its planarity gives it. The disocclusion
+ *    scales the history's weight.
  * 5. The history is clipped to the box, its weight capped so a tenth of each frame is always new, and
  *    the two are mixed by their weights. Where the pixel has gathered less than one sample's worth,
  *    the render read bicubically fills the gap. The history keeps colour and weight; the picture shown
@@ -33,7 +35,7 @@
  * buffer before a sample reaches this arithmetic, as the temporal resolve already does.
  */
 import { clipToBox, rgbToYCoCg, varianceBox, yCoCgToRgb } from './clamp.js';
-import { disocclusionWeight, normalFromPositions, worldPositionFromDepth } from './disocclusion.js';
+import { disocclusionWeight, normalFromPositions, planarity, surfaceSlope, worldPositionFromDepth, } from './disocclusion.js';
 import { sampleBilinear, sampleHistoryBicubic5 } from './reproject.js';
 /**
  * A tenth of each frame kept, as the temporal resolve keeps; a box of a standard deviation and a
@@ -131,6 +133,39 @@ function worldAt(depths, inverse, jitter, width, height, x, y, out) {
         m[15];
     return 1 / w;
 }
+/**
+ * A texel's view depth at its unjittered uv, or 0 — `worldAt` without the position, which is all a
+ * search over depths needs: one row of the inverse rather than four. Zero off the picture, where
+ * `worldAt` would clamp, because a neighbour that is not there is not a step.
+ */
+function viewDepthAt(depths, inverse, jitter, width, height, x, y) {
+    if (x < 0 || y < 0 || x >= width || y >= height)
+        return 0;
+    const u = (x + 0.5 - jitter[0]) / width;
+    const v = (y + 0.5 - jitter[1]) / height;
+    const m = inverse;
+    const w = m[3] * (u * 2 - 1) +
+        m[7] * (v * 2 - 1) +
+        m[11] * depths[y * width + x] +
+        m[15];
+    return Math.abs(w) > 1e-12 ? 1 / w : 0;
+}
+/** What a texel's four neighbours say about its surface: see `planarity` and `surfaceSlope`. */
+const SURFACE = { planar: 1, slope: 0 };
+function surfaceAt(depths, inverse, jitter, width, height, x, y, centre) {
+    let planar = 1;
+    let slope = 0;
+    for (let axis = 0; axis < 2; axis += 1) {
+        const ax = 1 - axis;
+        const ay = axis;
+        const after = viewDepthAt(depths, inverse, jitter, width, height, x + ax, y + ay);
+        const before = viewDepthAt(depths, inverse, jitter, width, height, x - ax, y - ay);
+        planar *= planarity(before, centre, after);
+        slope = Math.max(slope, surfaceSlope(before, centre, after));
+    }
+    SURFACE.planar = planar;
+    SURFACE.slope = slope;
+}
 /** The world normal at a texel, from its depth and its right and upper neighbours'. */
 function normalAt(depths, inverse, jitter, eye, width, height, x, y, out) {
     if (worldAt(depths, inverse, jitter, width, height, x, y, WORLD) <= 0)
@@ -190,18 +225,66 @@ function historyWeight(frame, u, v, dx, dy) {
     if (!(pu >= 0 && pu <= 1 && pv >= 0 && pv <= 1))
         return 0;
     sampleHistoryBicubic5(frame.history, pu * frame.outputWidth - 0.5, pv * frame.outputHeight - 0.5, frame.outputWidth, frame.outputHeight, 4, HISTORY);
-    const px = clampTexel(Math.round(pu * rw + frame.previousJitter[0] - 0.5), rw);
-    const py = clampTexel(Math.round(pv * rh + frame.previousJitter[1] - 0.5), rh);
-    const held = worldAt(frame.previousDepth, frame.previousInverseViewProj, frame.previousJitter, rw, rh, px, py, RIGHT);
+    /*
+     * **Last frame's depth is searched for this surface, around where the dilated texel was.** The
+     * surface being judged is the dilated texel's, which beside an edge is a neighbour's, so judging
+     * it by the texel under the pixel compares two surfaces: the side of every silhouette away from the
+     * eye dropped its history on every frame of a still picture. And a new jitter samples a surface
+     * somewhere else, so the nearest of last frame's nine is taken rather than the one the rounding
+     * picks. What it gives up is a disocclusion narrower than a texel, which keeps a history that the
+     * neighbourhood clip then bounds.
+     */
+    const su = (dx + 0.5 - frame.jitter[0]) / rw + mu;
+    const sv = (dy + 0.5 - frame.jitter[1]) / rh + mv;
+    const cx = clampTexel(Math.round(su * rw + frame.previousJitter[0] - 0.5), rw);
+    const cy = clampTexel(Math.round(sv * rh + frame.previousJitter[1] - 0.5), rh);
+    /*
+     * The first texel looked at answers alone when it agrees within the tolerance, which it does
+     * everywhere but at an edge: the depth test trusts it fully whichever texel would have won, so
+     * only an edge pays for the other eight.
+     */
+    let held = viewDepthAt(frame.previousDepth, frame.previousInverseViewProj, frame.previousJitter, rw, rh, cx, cy);
+    let px = cx;
+    let py = cy;
+    if (!(held > 0 && Math.abs(held - expected) <= frame.disocclusion.depthTolerance * expected)) {
+        held = 0;
+        let nearest = Number.POSITIVE_INFINITY;
+        for (let j = -1; j <= 1; j += 1) {
+            for (let i = -1; i <= 1; i += 1) {
+                const tx = clampTexel(cx + i, rw);
+                const ty = clampTexel(cy + j, rh);
+                const depth = viewDepthAt(frame.previousDepth, frame.previousInverseViewProj, frame.previousJitter, rw, rh, tx, ty);
+                if (!(depth > 0))
+                    continue;
+                const off = Math.abs(depth - expected);
+                if (off < nearest) {
+                    nearest = off;
+                    held = depth;
+                    px = tx;
+                    py = ty;
+                }
+            }
+        }
+    }
+    const here = viewDepthAt(frame.depth, frame.inverseViewProj, frame.jitter, rw, rh, dx, dy);
+    surfaceAt(frame.depth, frame.inverseViewProj, frame.jitter, rw, rh, dx, dy, here);
+    const slope = SURFACE.slope;
+    let planar = SURFACE.planar;
+    if (planar > 0) {
+        surfaceAt(frame.previousDepth, frame.previousInverseViewProj, frame.previousJitter, rw, rh, px, py, held);
+        planar *= SURFACE.planar;
+    }
+    /* A normal has the say its planarity gives it; at an edge or a sliver, none, and none is computed. */
     let normalDot = 1;
-    if (normalAt(frame.depth, frame.inverseViewProj, frame.jitter, frame.eye, rw, rh, dx, dy, NORMAL) &&
+    if (planar > 0 &&
+        normalAt(frame.depth, frame.inverseViewProj, frame.jitter, frame.eye, rw, rh, dx, dy, NORMAL) &&
         normalAt(frame.previousDepth, frame.previousInverseViewProj, frame.previousJitter, frame.previousEye, rw, rh, px, py, PREVIOUS_NORMAL)) {
-        normalDot =
-            NORMAL[0] * PREVIOUS_NORMAL[0] +
-                NORMAL[1] * PREVIOUS_NORMAL[1] +
-                NORMAL[2] * PREVIOUS_NORMAL[2];
+        const cosine = NORMAL[0] * PREVIOUS_NORMAL[0] +
+            NORMAL[1] * PREVIOUS_NORMAL[1] +
+            NORMAL[2] * PREVIOUS_NORMAL[2];
+        normalDot = 1 - planar * (1 - cosine);
     }
-    const trust = disocclusionWeight(expected, held, Math.hypot(mu, mv), normalDot, frame.disocclusion);
+    const trust = disocclusionWeight(expected, held, Math.hypot(mu, mv), normalDot, frame.disocclusion, slope);
     return HISTORY[3] * trust;
 }
 /**

package/dist/render/sceneTarget.d.ts

@@ -303,6 +303,8 @@ export declare class SceneTarget {
     }, veilColor?: Vec3, veilAlpha?: number, temporal?: {
         readonly reprojection: Float32Array;
         readonly blend: number;
+        readonly periodStart: boolean;
+        readonly depthToViewZ: Float32Array;
     }): void;
     dispose(): void;
 }

package/dist/render/sceneTarget.js

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

package/dist/render/shaders/generated/temporalResolve.wgsl.d.ts

@@ -1,4 +1,4 @@
-export declare const TEMPORAL_RESOLVE_FRAG_WGSL = "struct Uniforms {\n    uReprojection: mat4x4<f32>,\n    uTexel: vec2<f32>,\n    uHistoryBlend: f32,\n}\n\n@group(0) @binding(32) \nvar uScene_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uScene_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(34) \nvar uHistory_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uHistory_s: sampler;\nvar<private> fragColor: vec4<f32>;\n@group(0) @binding(36) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(37) \nvar uDepth_s: sampler;\n\nfn clipToNeighbourhood_u0028_vf3_u003b_vf3_u003b_vf3_u003b(history: ptr<function, vec3<f32>>, lo: ptr<function, vec3<f32>>, hi: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var centre: vec3<f32>;\n    var extent: vec3<f32>;\n    var offset: vec3<f32>;\n    var ratios: vec3<f32>;\n    var ratio: f32;\n\n    let _e39 = (*lo);\n    let _e40 = (*hi);\n    centre = ((_e39 + _e40) * 0.5f);\n    let _e43 = (*hi);\n    let _e44 = (*lo);\n    extent = ((_e43 - _e44) * 0.5f);\n    let _e47 = (*history);\n    let _e48 = centre;\n    offset = (_e47 - _e48);\n    let _e50 = offset;\n    let _e52 = extent;\n    ratios = (abs(_e50) / max(_e52, vec3<f32>(0.0000001f, 0.0000001f, 0.0000001f)));\n    let _e56 = ratios[0u];\n    let _e58 = ratios[1u];\n    let _e60 = ratios[2u];\n    ratio = max(_e56, max(_e58, _e60));\n    let _e63 = ratio;\n    if (_e63 <= 1f) {\n        let _e65 = (*history);\n        return _e65;\n    }\n    let _e66 = centre;\n    let _e67 = offset;\n    let _e68 = ratio;\n    return (_e66 + (_e67 / vec3(_e68)));\n}\n\nfn historyCatmullRom_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {\n    var size: vec2<f32>;\n    var at: vec2<f32>;\n    var base: vec2<f32>;\n    var f: vec2<f32>;\n    var w0_: vec2<f32>;\n    var w1_: vec2<f32>;\n    var w2_: vec2<f32>;\n    var w3_: vec2<f32>;\n    var w12_: vec2<f32>;\n    var at0_: vec2<f32>;\n    var at3_: vec2<f32>;\n    var at12_: vec2<f32>;\n    var sum: vec3<f32>;\n    var weight: f32;\n\n    let _e47 = unnamed.uTexel;\n    size = (vec2(1f) / _e47);\n    let _e50 = (*uv);\n    let _e51 = size;\n    at = (_e50 * _e51);\n    let _e53 = at;\n    base = (floor((_e53 - vec2(0.5f))) + vec2(0.5f));\n    let _e59 = at;\n    let _e60 = base;\n    f = (_e59 - _e60);\n    let _e62 = f;\n    let _e63 = f;\n    let _e64 = f;\n    w0_ = (_e62 * (vec2(-0.5f) + (_e63 * (vec2(1f) - (_e64 * 0.5f)))));\n    let _e72 = f;\n    let _e73 = f;\n    let _e75 = f;\n    w1_ = (vec2(1f) + ((_e72 * _e73) * (vec2(-2.5f) + (_e75 * 1.5f))));\n    let _e82 = f;\n    let _e83 = f;\n    let _e84 = f;\n    w2_ = (_e82 * (vec2(0.5f) + (_e83 * (vec2(2f) - (_e84 * 1.5f)))));\n    let _e92 = f;\n    let _e93 = f;\n    let _e95 = f;\n    w3_ = ((_e92 * _e93) * (vec2(-0.5f) + (_e95 * 0.5f)));\n    let _e100 = w1_;\n    let _e101 = w2_;\n    w12_ = (_e100 + _e101);\n    let _e103 = base;\n    let _e107 = unnamed.uTexel;\n    at0_ = ((_e103 - vec2(1f)) * _e107);\n    let _e109 = base;\n    let _e113 = unnamed.uTexel;\n    at3_ = ((_e109 + vec2(2f)) * _e113);\n    let _e115 = base;\n    let _e116 = w2_;\n    let _e117 = w12_;\n    let _e121 = unnamed.uTexel;\n    at12_ = ((_e115 + (_e116 / _e117)) * _e121);\n    let _e124 = at12_[0u];\n    let _e126 = at0_[1u];\n    let _e128 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e124, _e126), 0f);\n    let _e131 = w12_[0u];\n    let _e133 = w0_[1u];\n    let _e137 = at0_[0u];\n    let _e139 = at12_[1u];\n    let _e141 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e137, _e139), 0f);\n    let _e144 = w0_[0u];\n    let _e146 = w12_[1u];\n    let _e150 = at12_;\n    let _e151 = textureSampleLevel(uHistory_t, uHistory_s, _e150, 0f);\n    let _e154 = w12_[0u];\n    let _e156 = w12_[1u];\n    let _e161 = at3_[0u];\n    let _e163 = at12_[1u];\n    let _e165 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e161, _e163), 0f);\n    let _e168 = w3_[0u];\n    let _e170 = w12_[1u];\n    let _e175 = at12_[0u];\n    let _e177 = at3_[1u];\n    let _e179 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e175, _e177), 0f);\n    let _e182 = w12_[0u];\n    let _e184 = w3_[1u];\n    sum = (((((_e128.xyz * (_e131 * _e133)) + (_e141.xyz * (_e144 * _e146))) + (_e151.xyz * (_e154 * _e156))) + (_e165.xyz * (_e168 * _e170))) + (_e179.xyz * (_e182 * _e184)));\n    let _e189 = w12_[0u];\n    let _e191 = w0_[1u];\n    let _e194 = w0_[0u];\n    let _e196 = w12_[1u];\n    let _e200 = w12_[0u];\n    let _e202 = w12_[1u];\n    let _e206 = w3_[0u];\n    let _e208 = w12_[1u];\n    let _e212 = w12_[0u];\n    let _e214 = w3_[1u];\n    weight = (((((_e189 * _e191) + (_e194 * _e196)) + (_e200 * _e202)) + (_e206 * _e208)) + (_e212 * _e214));\n    let _e217 = sum;\n    let _e218 = weight;\n    return max((_e217 / vec3(_e218)), vec3<f32>(0f, 0f, 0f));\n}\n\nfn neighbourhood_u0028_vf3_u003b_vf3_u003b(lo_1: ptr<function, vec3<f32>>, hi_1: ptr<function, vec3<f32>>) {\n    var y: i32;\n    var x: i32;\n    var c: vec3<f32>;\n\n    (*lo_1) = vec3<f32>(1000000000f, 1000000000f, 1000000000f);\n    (*hi_1) = vec3<f32>(-1000000000f, -1000000000f, -1000000000f);\n    y = -1i;\n    loop {\n        let _e36 = y;\n        if (_e36 <= 1i) {\n            x = -1i;\n            loop {\n                let _e38 = x;\n                if (_e38 <= 1i) {\n                    let _e40 = vUv_1;\n                    let _e41 = x;\n                    let _e43 = y;\n                    let _e47 = unnamed.uTexel;\n                    let _e50 = textureSampleLevel(uScene_t, uScene_s, (_e40 + (vec2<f32>(f32(_e41), f32(_e43)) * _e47)), 0f);\n                    c = _e50.xyz;\n                    let _e52 = (*lo_1);\n                    let _e53 = c;\n                    (*lo_1) = min(_e52, _e53);\n                    let _e55 = (*hi_1);\n                    let _e56 = c;\n                    (*hi_1) = max(_e55, _e56);\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e58 = x;\n                    x = (_e58 + 1i);\n                }\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e60 = y;\n            y = (_e60 + 1i);\n        }\n    }\n    return;\n}\n\nfn main_1() {\n    var current: vec3<f32>;\n    var depth: f32;\n    var clip: vec4<f32>;\n    var previous: vec4<f32>;\n    var wasUv: vec2<f32>;\n    var lo_2: vec3<f32>;\n    var hi_2: vec3<f32>;\n    var param: vec3<f32>;\n    var param_1: vec3<f32>;\n    var history_1: vec3<f32>;\n    var param_2: vec2<f32>;\n    var bounded: vec3<f32>;\n    var param_3: vec3<f32>;\n    var param_4: vec3<f32>;\n    var param_5: vec3<f32>;\n    var phi_440_: bool;\n    var phi_447_: bool;\n    var phi_454_: bool;\n\n    let _e46 = vUv_1;\n    let _e47 = textureSampleLevel(uScene_t, uScene_s, _e46, 0f);\n    current = _e47.xyz;\n    let _e50 = unnamed.uHistoryBlend;\n    if (_e50 <= 0f) {\n        let _e52 = current;\n        fragColor = vec4<f32>(_e52.x, _e52.y, _e52.z, 1f);\n        return;\n    }\n    let _e57 = vUv_1;\n    let _e58 = textureSampleLevel(uDepth_t, uDepth_s, _e57, 0f);\n    depth = _e58.x;\n    let _e60 = vUv_1;\n    let _e63 = ((_e60 * 2f) - vec2(1f));\n    let _e64 = depth;\n    clip = vec4<f32>(_e63.x, _e63.y, (1f - (_e64 * 2f)), 1f);\n    let _e71 = unnamed.uReprojection;\n    let _e72 = clip;\n    previous = (_e71 * _e72);\n    let _e75 = previous[3u];\n    if (_e75 <= 0f) {\n        let _e77 = current;\n        fragColor = vec4<f32>(_e77.x, _e77.y, _e77.z, 1f);\n        return;\n    }\n    let _e82 = previous;\n    let _e85 = previous[3u];\n    wasUv = (((_e82.xy / vec2(_e85)) * 0.5f) + vec2(0.5f));\n    let _e92 = wasUv[0u];\n    let _e93 = (_e92 < 0f);\n    phi_440_ = _e93;\n    if !(_e93) {\n        let _e96 = wasUv[0u];\n        phi_440_ = (_e96 > 1f);\n    }\n    let _e99 = phi_440_;\n    phi_447_ = _e99;\n    if !(_e99) {\n        let _e102 = wasUv[1u];\n        phi_447_ = (_e102 < 0f);\n    }\n    let _e105 = phi_447_;\n    phi_454_ = _e105;\n    if !(_e105) {\n        let _e108 = wasUv[1u];\n        phi_454_ = (_e108 > 1f);\n    }\n    let _e111 = phi_454_;\n    if _e111 {\n        let _e112 = current;\n        fragColor = vec4<f32>(_e112.x, _e112.y, _e112.z, 1f);\n        return;\n    }\n    neighbourhood_u0028_vf3_u003b_vf3_u003b((&param), (&param_1));\n    let _e117 = param;\n    lo_2 = _e117;\n    let _e118 = param_1;\n    hi_2 = _e118;\n    let _e119 = wasUv;\n    param_2 = _e119;\n    let _e120 = historyCatmullRom_u0028_vf2_u003b((&param_2));\n    history_1 = _e120;\n    let _e121 = history_1;\n    param_3 = _e121;\n    let _e122 = lo_2;\n    param_4 = _e122;\n    let _e123 = hi_2;\n    param_5 = _e123;\n    let _e124 = clipToNeighbourhood_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_3), (&param_4), (&param_5));\n    bounded = _e124;\n    let _e125 = current;\n    let _e126 = bounded;\n    let _e128 = unnamed.uHistoryBlend;\n    let _e130 = mix(_e125, _e126, vec3(_e128));\n    fragColor = vec4<f32>(_e130.x, _e130.y, _e130.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
+export declare const TEMPORAL_RESOLVE_FRAG_WGSL = "struct Uniforms {\n    uDepthToViewZ: vec4<f32>,\n    uAntiFlicker: f32,\n    uReprojection: mat4x4<f32>,\n    uTexel: vec2<f32>,\n    uPeriodStart: f32,\n    uHistoryBlend: f32,\n}\n\nstruct FragmentOutput {\n    @location(0) member: vec4<f32>,\n    @location(1) member_1: vec4<f32>,\n    @location(2) member_2: vec4<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uScene_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uScene_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(34) \nvar uHistory_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uHistory_s: sampler;\nvar<private> fragColor: vec4<f32>;\nvar<private> flickerOut: vec4<f32>;\nvar<private> flickerMotionOut: vec4<f32>;\n@group(0) @binding(40) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(41) \nvar uDepth_s: sampler;\n@group(0) @binding(36) \nvar uFlicker_t: texture_2d<f32>;\n@group(0) @binding(38) \nvar uFlickerMotion_t: texture_2d<f32>;\n@group(0) @binding(37) \nvar uFlicker_s: sampler;\n@group(0) @binding(39) \nvar uFlickerMotion_s: sampler;\n\nfn repeats_u0028_f1_u003b_f1_u003b(mean: ptr<function, f32>, previous: ptr<function, f32>) -> f32 {\n    var apart: f32;\n\n    let _e63 = (*mean);\n    let _e64 = (*previous);\n    let _e67 = (*mean);\n    let _e68 = (*previous);\n    apart = (abs((_e63 - _e64)) / max(max(_e67, _e68), 0.003921569f));\n    let _e72 = apart;\n    return (1f - smoothstep(0.05f, 0.1f, _e72));\n}\n\nfn clipToNeighbourhood_u0028_vf3_u003b_vf3_u003b_vf3_u003b(history: ptr<function, vec3<f32>>, lo: ptr<function, vec3<f32>>, hi: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var centre: vec3<f32>;\n    var extent: vec3<f32>;\n    var offset: vec3<f32>;\n    var ratios: vec3<f32>;\n    var ratio: f32;\n\n    let _e68 = (*lo);\n    let _e69 = (*hi);\n    centre = ((_e68 + _e69) * 0.5f);\n    let _e72 = (*hi);\n    let _e73 = (*lo);\n    extent = ((_e72 - _e73) * 0.5f);\n    let _e76 = (*history);\n    let _e77 = centre;\n    offset = (_e76 - _e77);\n    let _e79 = offset;\n    let _e81 = extent;\n    ratios = (abs(_e79) / max(_e81, vec3<f32>(0.0000001f, 0.0000001f, 0.0000001f)));\n    let _e85 = ratios[0u];\n    let _e87 = ratios[1u];\n    let _e89 = ratios[2u];\n    ratio = max(_e85, max(_e87, _e89));\n    let _e92 = ratio;\n    if (_e92 <= 1f) {\n        let _e94 = (*history);\n        return _e94;\n    }\n    let _e95 = centre;\n    let _e96 = offset;\n    let _e97 = ratio;\n    return (_e95 + (_e96 / vec3(_e97)));\n}\n\nfn luma_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> f32 {\n    let _e61 = (*c);\n    return dot(_e61, vec3<f32>(0.2126f, 0.7152f, 0.0722f));\n}\n\nfn historyCatmullRom_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {\n    var size: vec2<f32>;\n    var at: vec2<f32>;\n    var base: vec2<f32>;\n    var f: vec2<f32>;\n    var w0_: vec2<f32>;\n    var w1_: vec2<f32>;\n    var w2_: vec2<f32>;\n    var w3_: vec2<f32>;\n    var w12_: vec2<f32>;\n    var at0_: vec2<f32>;\n    var at3_: vec2<f32>;\n    var at12_: vec2<f32>;\n    var sum: vec3<f32>;\n    var weight: f32;\n\n    let _e76 = unnamed.uTexel;\n    size = (vec2(1f) / _e76);\n    let _e79 = (*uv);\n    let _e80 = size;\n    at = (_e79 * _e80);\n    let _e82 = at;\n    base = (floor((_e82 - vec2(0.5f))) + vec2(0.5f));\n    let _e88 = at;\n    let _e89 = base;\n    f = (_e88 - _e89);\n    let _e91 = f;\n    let _e92 = f;\n    let _e93 = f;\n    w0_ = (_e91 * (vec2(-0.5f) + (_e92 * (vec2(1f) - (_e93 * 0.5f)))));\n    let _e101 = f;\n    let _e102 = f;\n    let _e104 = f;\n    w1_ = (vec2(1f) + ((_e101 * _e102) * (vec2(-2.5f) + (_e104 * 1.5f))));\n    let _e111 = f;\n    let _e112 = f;\n    let _e113 = f;\n    w2_ = (_e111 * (vec2(0.5f) + (_e112 * (vec2(2f) - (_e113 * 1.5f)))));\n    let _e121 = f;\n    let _e122 = f;\n    let _e124 = f;\n    w3_ = ((_e121 * _e122) * (vec2(-0.5f) + (_e124 * 0.5f)));\n    let _e129 = w1_;\n    let _e130 = w2_;\n    w12_ = (_e129 + _e130);\n    let _e132 = base;\n    let _e136 = unnamed.uTexel;\n    at0_ = ((_e132 - vec2(1f)) * _e136);\n    let _e138 = base;\n    let _e142 = unnamed.uTexel;\n    at3_ = ((_e138 + vec2(2f)) * _e142);\n    let _e144 = base;\n    let _e145 = w2_;\n    let _e146 = w12_;\n    let _e150 = unnamed.uTexel;\n    at12_ = ((_e144 + (_e145 / _e146)) * _e150);\n    let _e153 = at12_[0u];\n    let _e155 = at0_[1u];\n    let _e157 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e153, _e155), 0f);\n    let _e160 = w12_[0u];\n    let _e162 = w0_[1u];\n    let _e166 = at0_[0u];\n    let _e168 = at12_[1u];\n    let _e170 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e166, _e168), 0f);\n    let _e173 = w0_[0u];\n    let _e175 = w12_[1u];\n    let _e179 = at12_;\n    let _e180 = textureSampleLevel(uHistory_t, uHistory_s, _e179, 0f);\n    let _e183 = w12_[0u];\n    let _e185 = w12_[1u];\n    let _e190 = at3_[0u];\n    let _e192 = at12_[1u];\n    let _e194 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e190, _e192), 0f);\n    let _e197 = w3_[0u];\n    let _e199 = w12_[1u];\n    let _e204 = at12_[0u];\n    let _e206 = at3_[1u];\n    let _e208 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e204, _e206), 0f);\n    let _e211 = w12_[0u];\n    let _e213 = w3_[1u];\n    sum = (((((_e157.xyz * (_e160 * _e162)) + (_e170.xyz * (_e173 * _e175))) + (_e180.xyz * (_e183 * _e185))) + (_e194.xyz * (_e197 * _e199))) + (_e208.xyz * (_e211 * _e213)));\n    let _e218 = w12_[0u];\n    let _e220 = w0_[1u];\n    let _e223 = w0_[0u];\n    let _e225 = w12_[1u];\n    let _e229 = w12_[0u];\n    let _e231 = w12_[1u];\n    let _e235 = w3_[0u];\n    let _e237 = w12_[1u];\n    let _e241 = w12_[0u];\n    let _e243 = w3_[1u];\n    weight = (((((_e218 * _e220) + (_e223 * _e225)) + (_e229 * _e231)) + (_e235 * _e237)) + (_e241 * _e243));\n    let _e246 = sum;\n    let _e247 = weight;\n    return max((_e246 / vec3(_e247)), vec3<f32>(0f, 0f, 0f));\n}\n\nfn neighbourhood_u0028_vf3_u003b_vf3_u003b(lo_1: ptr<function, vec3<f32>>, hi_1: ptr<function, vec3<f32>>) {\n    var y: i32;\n    var x: i32;\n    var c_1: vec3<f32>;\n\n    (*lo_1) = vec3<f32>(1000000000f, 1000000000f, 1000000000f);\n    (*hi_1) = vec3<f32>(-1000000000f, -1000000000f, -1000000000f);\n    y = -1i;\n    loop {\n        let _e65 = y;\n        if (_e65 <= 1i) {\n            x = -1i;\n            loop {\n                let _e67 = x;\n                if (_e67 <= 1i) {\n                    let _e69 = vUv_1;\n                    let _e70 = x;\n                    let _e72 = y;\n                    let _e76 = unnamed.uTexel;\n                    let _e79 = textureSampleLevel(uScene_t, uScene_s, (_e69 + (vec2<f32>(f32(_e70), f32(_e72)) * _e76)), 0f);\n                    c_1 = _e79.xyz;\n                    let _e81 = (*lo_1);\n                    let _e82 = c_1;\n                    (*lo_1) = min(_e81, _e82);\n                    let _e84 = (*hi_1);\n                    let _e85 = c_1;\n                    (*hi_1) = max(_e84, _e85);\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e87 = x;\n                    x = (_e87 + 1i);\n                }\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e89 = y;\n            y = (_e89 + 1i);\n        }\n    }\n    return;\n}\n\nfn viewDepthOf_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {\n    var z: f32;\n\n    let _e62 = (*depth);\n    z = (1f - (_e62 * 2f));\n    let _e67 = unnamed.uDepthToViewZ[0u];\n    let _e68 = z;\n    let _e72 = unnamed.uDepthToViewZ[1u];\n    let _e77 = unnamed.uDepthToViewZ[2u];\n    let _e78 = z;\n    let _e82 = unnamed.uDepthToViewZ[3u];\n    return (-(((_e67 * _e68) + _e72)) / ((_e77 * _e78) + _e82));\n}\n\nfn freshRecord_u0028_vf3_u003b(current: ptr<function, vec3<f32>>) -> vec4<f32> {\n    var seen: f32;\n    var param: vec3<f32>;\n\n    let _e63 = (*current);\n    param = _e63;\n    let _e64 = luma_u0028_vf3_u003b((&param));\n    seen = _e64;\n    let _e65 = seen;\n    let _e67 = seen;\n    return vec4<f32>(0f, (_e65 * 0.125f), _e67, 0f);\n}\n\nfn main_1() {\n    var current_1: vec3<f32>;\n    var param_1: vec3<f32>;\n    var nearestAt: vec2<f32>;\n    var depth_1: f32;\n    var metres: f32;\n    var param_2: f32;\n    var y_1: i32;\n    var x_1: i32;\n    var at_1: vec2<f32>;\n    var tap: f32;\n    var tapMetres: f32;\n    var param_3: f32;\n    var clip: vec4<f32>;\n    var previous_1: vec4<f32>;\n    var param_4: vec3<f32>;\n    var wasUv: vec2<f32>;\n    var param_5: vec3<f32>;\n    var lo_2: vec3<f32>;\n    var hi_2: vec3<f32>;\n    var param_6: vec3<f32>;\n    var param_7: vec3<f32>;\n    var history_1: vec3<f32>;\n    var param_8: vec2<f32>;\n    var size_1: vec2<i32>;\n    var was: vec2<i32>;\n    var nearest: f32;\n    var n: i32;\n    var at_2: vec2<i32>;\n    var local: vec2<i32>;\n    var local_1: vec2<i32>;\n    var local_2: vec2<i32>;\n    var stood: f32;\n    var motionThere: vec4<f32>;\n    var missedAll: bool;\n    var same: bool;\n    var swingOut: f32;\n    var local_3: f32;\n    var seen_1: f32;\n    var param_9: vec3<f32>;\n    var held: vec4<f32>;\n    var local_4: vec4<f32>;\n    var param_10: vec3<f32>;\n    var still: f32;\n    var apart_1: f32;\n    var reach: f32;\n    var within: bool;\n    var proven: bool;\n    var widen: f32;\n    var local_5: f32;\n    var blend: f32;\n    var local_6: f32;\n    var bounded: vec3<f32>;\n    var param_11: vec3<f32>;\n    var param_12: vec3<f32>;\n    var param_13: vec3<f32>;\n    var sum_1: f32;\n    var mean_1: f32;\n    var repeated: f32;\n    var local_7: f32;\n    var param_14: f32;\n    var param_15: f32;\n    var local_8: f32;\n    var phi_589_: bool;\n    var phi_596_: bool;\n    var phi_603_: bool;\n    var phi_740_: bool;\n\n    let _e122 = vUv_1;\n    let _e123 = textureSampleLevel(uScene_t, uScene_s, _e122, 0f);\n    current_1 = _e123.xyz;\n    let _e126 = unnamed.uHistoryBlend;\n    if (_e126 <= 0f) {\n        let _e128 = current_1;\n        fragColor = vec4<f32>(_e128.x, _e128.y, _e128.z, 1f);\n        let _e133 = current_1;\n        param_1 = _e133;\n        let _e134 = freshRecord_u0028_vf3_u003b((&param_1));\n        flickerOut = _e134;\n        flickerMotionOut = vec4<f32>(0f, 0f, 0f, 0f);\n        return;\n    }\n    let _e135 = vUv_1;\n    nearestAt = _e135;\n    let _e136 = vUv_1;\n    let _e137 = textureSampleLevel(uDepth_t, uDepth_s, _e136, 0f);\n    depth_1 = _e137.x;\n    let _e139 = depth_1;\n    param_2 = _e139;\n    let _e140 = viewDepthOf_u0028_f1_u003b((&param_2));\n    metres = _e140;\n    y_1 = -1i;\n    loop {\n        let _e141 = y_1;\n        if (_e141 <= 1i) {\n            x_1 = -1i;\n            loop {\n                let _e143 = x_1;\n                if (_e143 <= 1i) {\n                    let _e145 = vUv_1;\n                    let _e146 = x_1;\n                    let _e148 = y_1;\n                    let _e152 = unnamed.uTexel;\n                    at_1 = (_e145 + (vec2<f32>(f32(_e146), f32(_e148)) * _e152));\n                    let _e155 = at_1;\n                    let _e156 = textureSampleLevel(uDepth_t, uDepth_s, _e155, 0f);\n                    tap = _e156.x;\n                    let _e158 = tap;\n                    param_3 = _e158;\n                    let _e159 = viewDepthOf_u0028_f1_u003b((&param_3));\n                    tapMetres = _e159;\n                    let _e160 = tapMetres;\n                    let _e161 = metres;\n                    if (_e160 < _e161) {\n                        let _e163 = tapMetres;\n                        metres = _e163;\n                        let _e164 = tap;\n                        depth_1 = _e164;\n                        let _e165 = at_1;\n                        nearestAt = _e165;\n                    }\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e166 = x_1;\n                    x_1 = (_e166 + 1i);\n                }\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e168 = y_1;\n            y_1 = (_e168 + 1i);\n        }\n    }\n    let _e170 = nearestAt;\n    let _e173 = ((_e170 * 2f) - vec2(1f));\n    let _e174 = depth_1;\n    clip = vec4<f32>(_e173.x, _e173.y, (1f - (_e174 * 2f)), 1f);\n    let _e181 = unnamed.uReprojection;\n    let _e182 = clip;\n    previous_1 = (_e181 * _e182);\n    let _e185 = previous_1[3u];\n    if (_e185 <= 0f) {\n        let _e187 = current_1;\n        fragColor = vec4<f32>(_e187.x, _e187.y, _e187.z, 1f);\n        let _e192 = current_1;\n        param_4 = _e192;\n        let _e193 = freshRecord_u0028_vf3_u003b((&param_4));\n        flickerOut = _e193;\n        let _e194 = metres;\n        flickerMotionOut = vec4<f32>(_e194, 0f, 0f, 0f);\n        return;\n    }\n    let _e196 = vUv_1;\n    let _e197 = previous_1;\n    let _e200 = previous_1[3u];\n    let _e206 = nearestAt;\n    wasUv = (_e196 + ((((_e197.xy / vec2(_e200)) * 0.5f) + vec2(0.5f)) - _e206));\n    let _e210 = wasUv[0u];\n    let _e211 = (_e210 < 0f);\n    phi_589_ = _e211;\n    if !(_e211) {\n        let _e214 = wasUv[0u];\n        phi_589_ = (_e214 > 1f);\n    }\n    let _e217 = phi_589_;\n    phi_596_ = _e217;\n    if !(_e217) {\n        let _e220 = wasUv[1u];\n        phi_596_ = (_e220 < 0f);\n    }\n    let _e223 = phi_596_;\n    phi_603_ = _e223;\n    if !(_e223) {\n        let _e226 = wasUv[1u];\n        phi_603_ = (_e226 > 1f);\n    }\n    let _e229 = phi_603_;\n    if _e229 {\n        let _e230 = current_1;\n        fragColor = vec4<f32>(_e230.x, _e230.y, _e230.z, 1f);\n        let _e235 = current_1;\n        param_5 = _e235;\n        let _e236 = freshRecord_u0028_vf3_u003b((&param_5));\n        flickerOut = _e236;\n        let _e237 = metres;\n        flickerMotionOut = vec4<f32>(_e237, 0f, 0f, 0f);\n        return;\n    }\n    neighbourhood_u0028_vf3_u003b_vf3_u003b((&param_6), (&param_7));\n    let _e239 = param_6;\n    lo_2 = _e239;\n    let _e240 = param_7;\n    hi_2 = _e240;\n    let _e241 = wasUv;\n    param_8 = _e241;\n    let _e242 = historyCatmullRom_u0028_vf2_u003b((&param_8));\n    history_1 = _e242;\n    let _e243 = textureDimensions(uFlicker_t, 0i);\n    size_1 = vec2<i32>(_e243);\n    let _e245 = wasUv;\n    let _e246 = size_1;\n    let _e250 = size_1;\n    was = clamp(vec2<i32>((_e245 * vec2<f32>(_e246))), vec2<i32>(0i, 0i), (_e250 - vec2(1i)));\n    nearest = 1000000000f;\n    n = 0i;\n    loop {\n        let _e254 = n;\n        if (_e254 < 5i) {\n            let _e256 = was;\n            let _e257 = n;\n            if (_e257 == 1i) {\n                local = vec2<i32>(1i, 0i);\n            } else {\n                let _e259 = n;\n                if (_e259 == 2i) {\n                    local_1 = vec2<i32>(-1i, 0i);\n                } else {\n                    let _e261 = n;\n                    if (_e261 == 3i) {\n                        local_2 = vec2<i32>(0i, 1i);\n                    } else {\n                        let _e263 = n;\n                        local_2 = select(vec2<i32>(0i, 0i), vec2<i32>(0i, -1i), vec2((_e263 == 4i)));\n                    }\n                    let _e267 = local_2;\n                    local_1 = _e267;\n                }\n                let _e268 = local_1;\n                local = _e268;\n            }\n            let _e269 = local;\n            at_2 = (_e256 + _e269);\n            let _e271 = at_2;\n            let _e272 = size_1;\n            let _e276 = textureLoad(uFlickerMotion_t, clamp(_e271, vec2<i32>(0i, 0i), (_e272 - vec2(1i))), 0i);\n            stood = _e276.x;\n            let _e278 = stood;\n            if (_e278 > 0f) {\n                let _e280 = nearest;\n                let _e281 = stood;\n                let _e283 = previous_1[3u];\n                nearest = min(_e280, abs((_e281 - _e283)));\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e287 = n;\n            n = (_e287 + 1i);\n        }\n    }\n    let _e289 = was;\n    let _e290 = textureLoad(uFlickerMotion_t, _e289, 0i);\n    motionThere = _e290;\n    let _e291 = nearest;\n    missedAll = (_e291 > 100000000f);\n    let _e294 = unnamed.uAntiFlicker;\n    let _e296 = missedAll;\n    let _e298 = ((_e294 > 0.5f) && !(_e296));\n    phi_740_ = _e298;\n    if _e298 {\n        let _e299 = nearest;\n        let _e301 = motionThere[1u];\n        let _e304 = previous_1[3u];\n        phi_740_ = (_e299 <= ((6f * _e301) + (0.02f * _e304)));\n    }\n    let _e309 = phi_740_;\n    same = _e309;\n    let _e310 = missedAll;\n    if _e310 {\n        local_3 = 0f;\n    } else {\n        let _e312 = motionThere[1u];\n        let _e313 = nearest;\n        let _e315 = motionThere[1u];\n        local_3 = (_e312 + ((_e313 - _e315) * 0.125f));\n    }\n    let _e319 = local_3;\n    swingOut = _e319;\n    let _e320 = current_1;\n    param_9 = _e320;\n    let _e321 = luma_u0028_vf3_u003b((&param_9));\n    seen_1 = _e321;\n    let _e322 = same;\n    if _e322 {\n        let _e323 = was;\n        let _e324 = textureLoad(uFlicker_t, _e323, 0i);\n        local_4 = _e324;\n    } else {\n        let _e325 = current_1;\n        param_10 = _e325;\n        let _e326 = freshRecord_u0028_vf3_u003b((&param_10));\n        local_4 = _e326;\n    }\n    let _e327 = local_4;\n    held = _e327;\n    let _e328 = wasUv;\n    let _e329 = vUv_1;\n    let _e332 = unnamed.uTexel;\n    still = (1f - smoothstep(0.01f, 0.05f, length(((_e328 - _e329) / _e332))));\n    let _e337 = seen_1;\n    let _e339 = held[2u];\n    apart_1 = abs((_e337 - _e339));\n    let _e343 = held[0u];\n    reach = ((6f * _e343) + 0.003921569f);\n    let _e346 = apart_1;\n    let _e347 = reach;\n    within = (_e346 <= _e347);\n    let _e350 = held[3u];\n    let _e352 = within;\n    proven = ((_e350 > 0.75f) && _e352);\n    let _e354 = proven;\n    if _e354 {\n        let _e356 = held[0u];\n        let _e358 = still;\n        local_5 = ((6f * _e356) * _e358);\n    } else {\n        local_5 = 0f;\n    }\n    let _e360 = local_5;\n    widen = _e360;\n    let _e361 = proven;\n    if _e361 {\n        let _e363 = unnamed.uHistoryBlend;\n        let _e364 = still;\n        local_6 = mix(_e363, 0.97f, _e364);\n    } else {\n        let _e367 = unnamed.uHistoryBlend;\n        local_6 = _e367;\n    }\n    let _e368 = local_6;\n    blend = _e368;\n    let _e369 = lo_2;\n    let _e370 = widen;\n    let _e373 = hi_2;\n    let _e374 = widen;\n    let _e377 = history_1;\n    param_11 = _e377;\n    param_12 = (_e369 - vec3(_e370));\n    param_13 = (_e373 + vec3(_e374));\n    let _e378 = clipToNeighbourhood_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_11), (&param_12), (&param_13));\n    bounded = _e378;\n    let _e380 = held[1u];\n    sum_1 = _e380;\n    let _e382 = held[2u];\n    mean_1 = _e382;\n    let _e383 = within;\n    if _e383 {\n        let _e385 = held[3u];\n        local_7 = _e385;\n    } else {\n        local_7 = 0f;\n    }\n    let _e386 = local_7;\n    repeated = _e386;\n    let _e388 = unnamed.uPeriodStart;\n    if (_e388 > 0.5f) {\n        let _e390 = sum_1;\n        param_14 = _e390;\n        let _e391 = mean_1;\n        param_15 = _e391;\n        let _e392 = repeats_u0028_f1_u003b_f1_u003b((&param_14), (&param_15));\n        if (_e392 > 0.5f) {\n            let _e394 = repeated;\n            local_8 = min(1f, (_e394 + 0.5f));\n        } else {\n            local_8 = 0f;\n        }\n        let _e397 = local_8;\n        repeated = _e397;\n        let _e398 = sum_1;\n        mean_1 = _e398;\n        sum_1 = 0f;\n    }\n    let _e400 = held[0u];\n    let _e401 = apart_1;\n    let _e403 = held[0u];\n    let _e407 = sum_1;\n    let _e408 = seen_1;\n    let _e411 = mean_1;\n    let _e412 = repeated;\n    let _e413 = still;\n    flickerOut = vec4<f32>((_e400 + ((_e401 - _e403) * 0.125f)), (_e407 + (_e408 * 0.125f)), _e411, (_e412 * _e413));\n    let _e416 = metres;\n    let _e417 = swingOut;\n    flickerMotionOut = vec4<f32>(_e416, _e417, 0f, 0f);\n    let _e419 = current_1;\n    let _e420 = bounded;\n    let _e421 = blend;\n    let _e423 = mix(_e419, _e420, vec3(_e421));\n    fragColor = vec4<f32>(_e423.x, _e423.y, _e423.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> FragmentOutput {\n    vUv_1 = vUv;\n    main_1();\n    let _e5 = fragColor;\n    let _e6 = flickerOut;\n    let _e7 = flickerMotionOut;\n    return FragmentOutput(_e5, _e6, _e7);\n}\n";
 /**
  * What the transform assigned, so the renderer binds the same numbers.
  *
@@ -7,20 +7,35 @@ export declare const TEMPORAL_RESOLVE_FRAG_WGSL = "struct Uniforms {\n    uRepro
 export declare const TEMPORALRESOLVE_BINDINGS: {
     readonly TEMPORAL_RESOLVE_FRAG: {
         readonly uniforms: 1;
-        readonly uniformSize: 80;
+        readonly uniformSize: 112;
         readonly fields: {
-            readonly uReprojection: {
+            readonly uDepthToViewZ: {
                 readonly offset: 0;
+                readonly size: 16;
+                readonly type: "vec4";
+            };
+            readonly uAntiFlicker: {
+                readonly offset: 16;
+                readonly size: 4;
+                readonly type: "float";
+            };
+            readonly uReprojection: {
+                readonly offset: 32;
                 readonly size: 64;
                 readonly type: "mat4";
             };
             readonly uTexel: {
-                readonly offset: 64;
+                readonly offset: 96;
                 readonly size: 8;
                 readonly type: "vec2";
             };
+            readonly uPeriodStart: {
+                readonly offset: 104;
+                readonly size: 4;
+                readonly type: "float";
+            };
             readonly uHistoryBlend: {
-                readonly offset: 72;
+                readonly offset: 108;
                 readonly size: 4;
                 readonly type: "float";
             };
@@ -36,11 +51,21 @@ export declare const TEMPORALRESOLVE_BINDINGS: {
                 readonly sampler: 35;
                 readonly type: "sampler2D";
             };
-            readonly uDepth: {
+            readonly uFlicker: {
                 readonly texture: 36;
                 readonly sampler: 37;
                 readonly type: "sampler2D";
             };
+            readonly uFlickerMotion: {
+                readonly texture: 38;
+                readonly sampler: 39;
+                readonly type: "sampler2D";
+            };
+            readonly uDepth: {
+                readonly texture: 40;
+                readonly sampler: 41;
+                readonly type: "sampler2D";
+            };
         };
     };
 };

package/dist/render/shaders/generated/temporalResolve.wgsl.js

@@ -4,7 +4,7 @@
  * The GLSL beside this file is the source of truth. A hand edit here is discarded by
  * the next generation, and `npm run wgsl:check` fails the build when this is stale.
  */
-export const TEMPORAL_RESOLVE_FRAG_WGSL = "struct Uniforms {\n    uReprojection: mat4x4<f32>,\n    uTexel: vec2<f32>,\n    uHistoryBlend: f32,\n}\n\n@group(0) @binding(32) \nvar uScene_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uScene_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(34) \nvar uHistory_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uHistory_s: sampler;\nvar<private> fragColor: vec4<f32>;\n@group(0) @binding(36) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(37) \nvar uDepth_s: sampler;\n\nfn clipToNeighbourhood_u0028_vf3_u003b_vf3_u003b_vf3_u003b(history: ptr<function, vec3<f32>>, lo: ptr<function, vec3<f32>>, hi: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var centre: vec3<f32>;\n    var extent: vec3<f32>;\n    var offset: vec3<f32>;\n    var ratios: vec3<f32>;\n    var ratio: f32;\n\n    let _e39 = (*lo);\n    let _e40 = (*hi);\n    centre = ((_e39 + _e40) * 0.5f);\n    let _e43 = (*hi);\n    let _e44 = (*lo);\n    extent = ((_e43 - _e44) * 0.5f);\n    let _e47 = (*history);\n    let _e48 = centre;\n    offset = (_e47 - _e48);\n    let _e50 = offset;\n    let _e52 = extent;\n    ratios = (abs(_e50) / max(_e52, vec3<f32>(0.0000001f, 0.0000001f, 0.0000001f)));\n    let _e56 = ratios[0u];\n    let _e58 = ratios[1u];\n    let _e60 = ratios[2u];\n    ratio = max(_e56, max(_e58, _e60));\n    let _e63 = ratio;\n    if (_e63 <= 1f) {\n        let _e65 = (*history);\n        return _e65;\n    }\n    let _e66 = centre;\n    let _e67 = offset;\n    let _e68 = ratio;\n    return (_e66 + (_e67 / vec3(_e68)));\n}\n\nfn historyCatmullRom_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {\n    var size: vec2<f32>;\n    var at: vec2<f32>;\n    var base: vec2<f32>;\n    var f: vec2<f32>;\n    var w0_: vec2<f32>;\n    var w1_: vec2<f32>;\n    var w2_: vec2<f32>;\n    var w3_: vec2<f32>;\n    var w12_: vec2<f32>;\n    var at0_: vec2<f32>;\n    var at3_: vec2<f32>;\n    var at12_: vec2<f32>;\n    var sum: vec3<f32>;\n    var weight: f32;\n\n    let _e47 = unnamed.uTexel;\n    size = (vec2(1f) / _e47);\n    let _e50 = (*uv);\n    let _e51 = size;\n    at = (_e50 * _e51);\n    let _e53 = at;\n    base = (floor((_e53 - vec2(0.5f))) + vec2(0.5f));\n    let _e59 = at;\n    let _e60 = base;\n    f = (_e59 - _e60);\n    let _e62 = f;\n    let _e63 = f;\n    let _e64 = f;\n    w0_ = (_e62 * (vec2(-0.5f) + (_e63 * (vec2(1f) - (_e64 * 0.5f)))));\n    let _e72 = f;\n    let _e73 = f;\n    let _e75 = f;\n    w1_ = (vec2(1f) + ((_e72 * _e73) * (vec2(-2.5f) + (_e75 * 1.5f))));\n    let _e82 = f;\n    let _e83 = f;\n    let _e84 = f;\n    w2_ = (_e82 * (vec2(0.5f) + (_e83 * (vec2(2f) - (_e84 * 1.5f)))));\n    let _e92 = f;\n    let _e93 = f;\n    let _e95 = f;\n    w3_ = ((_e92 * _e93) * (vec2(-0.5f) + (_e95 * 0.5f)));\n    let _e100 = w1_;\n    let _e101 = w2_;\n    w12_ = (_e100 + _e101);\n    let _e103 = base;\n    let _e107 = unnamed.uTexel;\n    at0_ = ((_e103 - vec2(1f)) * _e107);\n    let _e109 = base;\n    let _e113 = unnamed.uTexel;\n    at3_ = ((_e109 + vec2(2f)) * _e113);\n    let _e115 = base;\n    let _e116 = w2_;\n    let _e117 = w12_;\n    let _e121 = unnamed.uTexel;\n    at12_ = ((_e115 + (_e116 / _e117)) * _e121);\n    let _e124 = at12_[0u];\n    let _e126 = at0_[1u];\n    let _e128 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e124, _e126), 0f);\n    let _e131 = w12_[0u];\n    let _e133 = w0_[1u];\n    let _e137 = at0_[0u];\n    let _e139 = at12_[1u];\n    let _e141 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e137, _e139), 0f);\n    let _e144 = w0_[0u];\n    let _e146 = w12_[1u];\n    let _e150 = at12_;\n    let _e151 = textureSampleLevel(uHistory_t, uHistory_s, _e150, 0f);\n    let _e154 = w12_[0u];\n    let _e156 = w12_[1u];\n    let _e161 = at3_[0u];\n    let _e163 = at12_[1u];\n    let _e165 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e161, _e163), 0f);\n    let _e168 = w3_[0u];\n    let _e170 = w12_[1u];\n    let _e175 = at12_[0u];\n    let _e177 = at3_[1u];\n    let _e179 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e175, _e177), 0f);\n    let _e182 = w12_[0u];\n    let _e184 = w3_[1u];\n    sum = (((((_e128.xyz * (_e131 * _e133)) + (_e141.xyz * (_e144 * _e146))) + (_e151.xyz * (_e154 * _e156))) + (_e165.xyz * (_e168 * _e170))) + (_e179.xyz * (_e182 * _e184)));\n    let _e189 = w12_[0u];\n    let _e191 = w0_[1u];\n    let _e194 = w0_[0u];\n    let _e196 = w12_[1u];\n    let _e200 = w12_[0u];\n    let _e202 = w12_[1u];\n    let _e206 = w3_[0u];\n    let _e208 = w12_[1u];\n    let _e212 = w12_[0u];\n    let _e214 = w3_[1u];\n    weight = (((((_e189 * _e191) + (_e194 * _e196)) + (_e200 * _e202)) + (_e206 * _e208)) + (_e212 * _e214));\n    let _e217 = sum;\n    let _e218 = weight;\n    return max((_e217 / vec3(_e218)), vec3<f32>(0f, 0f, 0f));\n}\n\nfn neighbourhood_u0028_vf3_u003b_vf3_u003b(lo_1: ptr<function, vec3<f32>>, hi_1: ptr<function, vec3<f32>>) {\n    var y: i32;\n    var x: i32;\n    var c: vec3<f32>;\n\n    (*lo_1) = vec3<f32>(1000000000f, 1000000000f, 1000000000f);\n    (*hi_1) = vec3<f32>(-1000000000f, -1000000000f, -1000000000f);\n    y = -1i;\n    loop {\n        let _e36 = y;\n        if (_e36 <= 1i) {\n            x = -1i;\n            loop {\n                let _e38 = x;\n                if (_e38 <= 1i) {\n                    let _e40 = vUv_1;\n                    let _e41 = x;\n                    let _e43 = y;\n                    let _e47 = unnamed.uTexel;\n                    let _e50 = textureSampleLevel(uScene_t, uScene_s, (_e40 + (vec2<f32>(f32(_e41), f32(_e43)) * _e47)), 0f);\n                    c = _e50.xyz;\n                    let _e52 = (*lo_1);\n                    let _e53 = c;\n                    (*lo_1) = min(_e52, _e53);\n                    let _e55 = (*hi_1);\n                    let _e56 = c;\n                    (*hi_1) = max(_e55, _e56);\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e58 = x;\n                    x = (_e58 + 1i);\n                }\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e60 = y;\n            y = (_e60 + 1i);\n        }\n    }\n    return;\n}\n\nfn main_1() {\n    var current: vec3<f32>;\n    var depth: f32;\n    var clip: vec4<f32>;\n    var previous: vec4<f32>;\n    var wasUv: vec2<f32>;\n    var lo_2: vec3<f32>;\n    var hi_2: vec3<f32>;\n    var param: vec3<f32>;\n    var param_1: vec3<f32>;\n    var history_1: vec3<f32>;\n    var param_2: vec2<f32>;\n    var bounded: vec3<f32>;\n    var param_3: vec3<f32>;\n    var param_4: vec3<f32>;\n    var param_5: vec3<f32>;\n    var phi_440_: bool;\n    var phi_447_: bool;\n    var phi_454_: bool;\n\n    let _e46 = vUv_1;\n    let _e47 = textureSampleLevel(uScene_t, uScene_s, _e46, 0f);\n    current = _e47.xyz;\n    let _e50 = unnamed.uHistoryBlend;\n    if (_e50 <= 0f) {\n        let _e52 = current;\n        fragColor = vec4<f32>(_e52.x, _e52.y, _e52.z, 1f);\n        return;\n    }\n    let _e57 = vUv_1;\n    let _e58 = textureSampleLevel(uDepth_t, uDepth_s, _e57, 0f);\n    depth = _e58.x;\n    let _e60 = vUv_1;\n    let _e63 = ((_e60 * 2f) - vec2(1f));\n    let _e64 = depth;\n    clip = vec4<f32>(_e63.x, _e63.y, (1f - (_e64 * 2f)), 1f);\n    let _e71 = unnamed.uReprojection;\n    let _e72 = clip;\n    previous = (_e71 * _e72);\n    let _e75 = previous[3u];\n    if (_e75 <= 0f) {\n        let _e77 = current;\n        fragColor = vec4<f32>(_e77.x, _e77.y, _e77.z, 1f);\n        return;\n    }\n    let _e82 = previous;\n    let _e85 = previous[3u];\n    wasUv = (((_e82.xy / vec2(_e85)) * 0.5f) + vec2(0.5f));\n    let _e92 = wasUv[0u];\n    let _e93 = (_e92 < 0f);\n    phi_440_ = _e93;\n    if !(_e93) {\n        let _e96 = wasUv[0u];\n        phi_440_ = (_e96 > 1f);\n    }\n    let _e99 = phi_440_;\n    phi_447_ = _e99;\n    if !(_e99) {\n        let _e102 = wasUv[1u];\n        phi_447_ = (_e102 < 0f);\n    }\n    let _e105 = phi_447_;\n    phi_454_ = _e105;\n    if !(_e105) {\n        let _e108 = wasUv[1u];\n        phi_454_ = (_e108 > 1f);\n    }\n    let _e111 = phi_454_;\n    if _e111 {\n        let _e112 = current;\n        fragColor = vec4<f32>(_e112.x, _e112.y, _e112.z, 1f);\n        return;\n    }\n    neighbourhood_u0028_vf3_u003b_vf3_u003b((&param), (&param_1));\n    let _e117 = param;\n    lo_2 = _e117;\n    let _e118 = param_1;\n    hi_2 = _e118;\n    let _e119 = wasUv;\n    param_2 = _e119;\n    let _e120 = historyCatmullRom_u0028_vf2_u003b((&param_2));\n    history_1 = _e120;\n    let _e121 = history_1;\n    param_3 = _e121;\n    let _e122 = lo_2;\n    param_4 = _e122;\n    let _e123 = hi_2;\n    param_5 = _e123;\n    let _e124 = clipToNeighbourhood_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_3), (&param_4), (&param_5));\n    bounded = _e124;\n    let _e125 = current;\n    let _e126 = bounded;\n    let _e128 = unnamed.uHistoryBlend;\n    let _e130 = mix(_e125, _e126, vec3(_e128));\n    fragColor = vec4<f32>(_e130.x, _e130.y, _e130.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
+export const TEMPORAL_RESOLVE_FRAG_WGSL = "struct Uniforms {\n    uDepthToViewZ: vec4<f32>,\n    uAntiFlicker: f32,\n    uReprojection: mat4x4<f32>,\n    uTexel: vec2<f32>,\n    uPeriodStart: f32,\n    uHistoryBlend: f32,\n}\n\nstruct FragmentOutput {\n    @location(0) member: vec4<f32>,\n    @location(1) member_1: vec4<f32>,\n    @location(2) member_2: vec4<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uScene_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uScene_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(34) \nvar uHistory_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uHistory_s: sampler;\nvar<private> fragColor: vec4<f32>;\nvar<private> flickerOut: vec4<f32>;\nvar<private> flickerMotionOut: vec4<f32>;\n@group(0) @binding(40) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(41) \nvar uDepth_s: sampler;\n@group(0) @binding(36) \nvar uFlicker_t: texture_2d<f32>;\n@group(0) @binding(38) \nvar uFlickerMotion_t: texture_2d<f32>;\n@group(0) @binding(37) \nvar uFlicker_s: sampler;\n@group(0) @binding(39) \nvar uFlickerMotion_s: sampler;\n\nfn repeats_u0028_f1_u003b_f1_u003b(mean: ptr<function, f32>, previous: ptr<function, f32>) -> f32 {\n    var apart: f32;\n\n    let _e63 = (*mean);\n    let _e64 = (*previous);\n    let _e67 = (*mean);\n    let _e68 = (*previous);\n    apart = (abs((_e63 - _e64)) / max(max(_e67, _e68), 0.003921569f));\n    let _e72 = apart;\n    return (1f - smoothstep(0.05f, 0.1f, _e72));\n}\n\nfn clipToNeighbourhood_u0028_vf3_u003b_vf3_u003b_vf3_u003b(history: ptr<function, vec3<f32>>, lo: ptr<function, vec3<f32>>, hi: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var centre: vec3<f32>;\n    var extent: vec3<f32>;\n    var offset: vec3<f32>;\n    var ratios: vec3<f32>;\n    var ratio: f32;\n\n    let _e68 = (*lo);\n    let _e69 = (*hi);\n    centre = ((_e68 + _e69) * 0.5f);\n    let _e72 = (*hi);\n    let _e73 = (*lo);\n    extent = ((_e72 - _e73) * 0.5f);\n    let _e76 = (*history);\n    let _e77 = centre;\n    offset = (_e76 - _e77);\n    let _e79 = offset;\n    let _e81 = extent;\n    ratios = (abs(_e79) / max(_e81, vec3<f32>(0.0000001f, 0.0000001f, 0.0000001f)));\n    let _e85 = ratios[0u];\n    let _e87 = ratios[1u];\n    let _e89 = ratios[2u];\n    ratio = max(_e85, max(_e87, _e89));\n    let _e92 = ratio;\n    if (_e92 <= 1f) {\n        let _e94 = (*history);\n        return _e94;\n    }\n    let _e95 = centre;\n    let _e96 = offset;\n    let _e97 = ratio;\n    return (_e95 + (_e96 / vec3(_e97)));\n}\n\nfn luma_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> f32 {\n    let _e61 = (*c);\n    return dot(_e61, vec3<f32>(0.2126f, 0.7152f, 0.0722f));\n}\n\nfn historyCatmullRom_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {\n    var size: vec2<f32>;\n    var at: vec2<f32>;\n    var base: vec2<f32>;\n    var f: vec2<f32>;\n    var w0_: vec2<f32>;\n    var w1_: vec2<f32>;\n    var w2_: vec2<f32>;\n    var w3_: vec2<f32>;\n    var w12_: vec2<f32>;\n    var at0_: vec2<f32>;\n    var at3_: vec2<f32>;\n    var at12_: vec2<f32>;\n    var sum: vec3<f32>;\n    var weight: f32;\n\n    let _e76 = unnamed.uTexel;\n    size = (vec2(1f) / _e76);\n    let _e79 = (*uv);\n    let _e80 = size;\n    at = (_e79 * _e80);\n    let _e82 = at;\n    base = (floor((_e82 - vec2(0.5f))) + vec2(0.5f));\n    let _e88 = at;\n    let _e89 = base;\n    f = (_e88 - _e89);\n    let _e91 = f;\n    let _e92 = f;\n    let _e93 = f;\n    w0_ = (_e91 * (vec2(-0.5f) + (_e92 * (vec2(1f) - (_e93 * 0.5f)))));\n    let _e101 = f;\n    let _e102 = f;\n    let _e104 = f;\n    w1_ = (vec2(1f) + ((_e101 * _e102) * (vec2(-2.5f) + (_e104 * 1.5f))));\n    let _e111 = f;\n    let _e112 = f;\n    let _e113 = f;\n    w2_ = (_e111 * (vec2(0.5f) + (_e112 * (vec2(2f) - (_e113 * 1.5f)))));\n    let _e121 = f;\n    let _e122 = f;\n    let _e124 = f;\n    w3_ = ((_e121 * _e122) * (vec2(-0.5f) + (_e124 * 0.5f)));\n    let _e129 = w1_;\n    let _e130 = w2_;\n    w12_ = (_e129 + _e130);\n    let _e132 = base;\n    let _e136 = unnamed.uTexel;\n    at0_ = ((_e132 - vec2(1f)) * _e136);\n    let _e138 = base;\n    let _e142 = unnamed.uTexel;\n    at3_ = ((_e138 + vec2(2f)) * _e142);\n    let _e144 = base;\n    let _e145 = w2_;\n    let _e146 = w12_;\n    let _e150 = unnamed.uTexel;\n    at12_ = ((_e144 + (_e145 / _e146)) * _e150);\n    let _e153 = at12_[0u];\n    let _e155 = at0_[1u];\n    let _e157 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e153, _e155), 0f);\n    let _e160 = w12_[0u];\n    let _e162 = w0_[1u];\n    let _e166 = at0_[0u];\n    let _e168 = at12_[1u];\n    let _e170 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e166, _e168), 0f);\n    let _e173 = w0_[0u];\n    let _e175 = w12_[1u];\n    let _e179 = at12_;\n    let _e180 = textureSampleLevel(uHistory_t, uHistory_s, _e179, 0f);\n    let _e183 = w12_[0u];\n    let _e185 = w12_[1u];\n    let _e190 = at3_[0u];\n    let _e192 = at12_[1u];\n    let _e194 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e190, _e192), 0f);\n    let _e197 = w3_[0u];\n    let _e199 = w12_[1u];\n    let _e204 = at12_[0u];\n    let _e206 = at3_[1u];\n    let _e208 = textureSampleLevel(uHistory_t, uHistory_s, vec2<f32>(_e204, _e206), 0f);\n    let _e211 = w12_[0u];\n    let _e213 = w3_[1u];\n    sum = (((((_e157.xyz * (_e160 * _e162)) + (_e170.xyz * (_e173 * _e175))) + (_e180.xyz * (_e183 * _e185))) + (_e194.xyz * (_e197 * _e199))) + (_e208.xyz * (_e211 * _e213)));\n    let _e218 = w12_[0u];\n    let _e220 = w0_[1u];\n    let _e223 = w0_[0u];\n    let _e225 = w12_[1u];\n    let _e229 = w12_[0u];\n    let _e231 = w12_[1u];\n    let _e235 = w3_[0u];\n    let _e237 = w12_[1u];\n    let _e241 = w12_[0u];\n    let _e243 = w3_[1u];\n    weight = (((((_e218 * _e220) + (_e223 * _e225)) + (_e229 * _e231)) + (_e235 * _e237)) + (_e241 * _e243));\n    let _e246 = sum;\n    let _e247 = weight;\n    return max((_e246 / vec3(_e247)), vec3<f32>(0f, 0f, 0f));\n}\n\nfn neighbourhood_u0028_vf3_u003b_vf3_u003b(lo_1: ptr<function, vec3<f32>>, hi_1: ptr<function, vec3<f32>>) {\n    var y: i32;\n    var x: i32;\n    var c_1: vec3<f32>;\n\n    (*lo_1) = vec3<f32>(1000000000f, 1000000000f, 1000000000f);\n    (*hi_1) = vec3<f32>(-1000000000f, -1000000000f, -1000000000f);\n    y = -1i;\n    loop {\n        let _e65 = y;\n        if (_e65 <= 1i) {\n            x = -1i;\n            loop {\n                let _e67 = x;\n                if (_e67 <= 1i) {\n                    let _e69 = vUv_1;\n                    let _e70 = x;\n                    let _e72 = y;\n                    let _e76 = unnamed.uTexel;\n                    let _e79 = textureSampleLevel(uScene_t, uScene_s, (_e69 + (vec2<f32>(f32(_e70), f32(_e72)) * _e76)), 0f);\n                    c_1 = _e79.xyz;\n                    let _e81 = (*lo_1);\n                    let _e82 = c_1;\n                    (*lo_1) = min(_e81, _e82);\n                    let _e84 = (*hi_1);\n                    let _e85 = c_1;\n                    (*hi_1) = max(_e84, _e85);\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e87 = x;\n                    x = (_e87 + 1i);\n                }\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e89 = y;\n            y = (_e89 + 1i);\n        }\n    }\n    return;\n}\n\nfn viewDepthOf_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {\n    var z: f32;\n\n    let _e62 = (*depth);\n    z = (1f - (_e62 * 2f));\n    let _e67 = unnamed.uDepthToViewZ[0u];\n    let _e68 = z;\n    let _e72 = unnamed.uDepthToViewZ[1u];\n    let _e77 = unnamed.uDepthToViewZ[2u];\n    let _e78 = z;\n    let _e82 = unnamed.uDepthToViewZ[3u];\n    return (-(((_e67 * _e68) + _e72)) / ((_e77 * _e78) + _e82));\n}\n\nfn freshRecord_u0028_vf3_u003b(current: ptr<function, vec3<f32>>) -> vec4<f32> {\n    var seen: f32;\n    var param: vec3<f32>;\n\n    let _e63 = (*current);\n    param = _e63;\n    let _e64 = luma_u0028_vf3_u003b((&param));\n    seen = _e64;\n    let _e65 = seen;\n    let _e67 = seen;\n    return vec4<f32>(0f, (_e65 * 0.125f), _e67, 0f);\n}\n\nfn main_1() {\n    var current_1: vec3<f32>;\n    var param_1: vec3<f32>;\n    var nearestAt: vec2<f32>;\n    var depth_1: f32;\n    var metres: f32;\n    var param_2: f32;\n    var y_1: i32;\n    var x_1: i32;\n    var at_1: vec2<f32>;\n    var tap: f32;\n    var tapMetres: f32;\n    var param_3: f32;\n    var clip: vec4<f32>;\n    var previous_1: vec4<f32>;\n    var param_4: vec3<f32>;\n    var wasUv: vec2<f32>;\n    var param_5: vec3<f32>;\n    var lo_2: vec3<f32>;\n    var hi_2: vec3<f32>;\n    var param_6: vec3<f32>;\n    var param_7: vec3<f32>;\n    var history_1: vec3<f32>;\n    var param_8: vec2<f32>;\n    var size_1: vec2<i32>;\n    var was: vec2<i32>;\n    var nearest: f32;\n    var n: i32;\n    var at_2: vec2<i32>;\n    var local: vec2<i32>;\n    var local_1: vec2<i32>;\n    var local_2: vec2<i32>;\n    var stood: f32;\n    var motionThere: vec4<f32>;\n    var missedAll: bool;\n    var same: bool;\n    var swingOut: f32;\n    var local_3: f32;\n    var seen_1: f32;\n    var param_9: vec3<f32>;\n    var held: vec4<f32>;\n    var local_4: vec4<f32>;\n    var param_10: vec3<f32>;\n    var still: f32;\n    var apart_1: f32;\n    var reach: f32;\n    var within: bool;\n    var proven: bool;\n    var widen: f32;\n    var local_5: f32;\n    var blend: f32;\n    var local_6: f32;\n    var bounded: vec3<f32>;\n    var param_11: vec3<f32>;\n    var param_12: vec3<f32>;\n    var param_13: vec3<f32>;\n    var sum_1: f32;\n    var mean_1: f32;\n    var repeated: f32;\n    var local_7: f32;\n    var param_14: f32;\n    var param_15: f32;\n    var local_8: f32;\n    var phi_589_: bool;\n    var phi_596_: bool;\n    var phi_603_: bool;\n    var phi_740_: bool;\n\n    let _e122 = vUv_1;\n    let _e123 = textureSampleLevel(uScene_t, uScene_s, _e122, 0f);\n    current_1 = _e123.xyz;\n    let _e126 = unnamed.uHistoryBlend;\n    if (_e126 <= 0f) {\n        let _e128 = current_1;\n        fragColor = vec4<f32>(_e128.x, _e128.y, _e128.z, 1f);\n        let _e133 = current_1;\n        param_1 = _e133;\n        let _e134 = freshRecord_u0028_vf3_u003b((&param_1));\n        flickerOut = _e134;\n        flickerMotionOut = vec4<f32>(0f, 0f, 0f, 0f);\n        return;\n    }\n    let _e135 = vUv_1;\n    nearestAt = _e135;\n    let _e136 = vUv_1;\n    let _e137 = textureSampleLevel(uDepth_t, uDepth_s, _e136, 0f);\n    depth_1 = _e137.x;\n    let _e139 = depth_1;\n    param_2 = _e139;\n    let _e140 = viewDepthOf_u0028_f1_u003b((&param_2));\n    metres = _e140;\n    y_1 = -1i;\n    loop {\n        let _e141 = y_1;\n        if (_e141 <= 1i) {\n            x_1 = -1i;\n            loop {\n                let _e143 = x_1;\n                if (_e143 <= 1i) {\n                    let _e145 = vUv_1;\n                    let _e146 = x_1;\n                    let _e148 = y_1;\n                    let _e152 = unnamed.uTexel;\n                    at_1 = (_e145 + (vec2<f32>(f32(_e146), f32(_e148)) * _e152));\n                    let _e155 = at_1;\n                    let _e156 = textureSampleLevel(uDepth_t, uDepth_s, _e155, 0f);\n                    tap = _e156.x;\n                    let _e158 = tap;\n                    param_3 = _e158;\n                    let _e159 = viewDepthOf_u0028_f1_u003b((&param_3));\n                    tapMetres = _e159;\n                    let _e160 = tapMetres;\n                    let _e161 = metres;\n                    if (_e160 < _e161) {\n                        let _e163 = tapMetres;\n                        metres = _e163;\n                        let _e164 = tap;\n                        depth_1 = _e164;\n                        let _e165 = at_1;\n                        nearestAt = _e165;\n                    }\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e166 = x_1;\n                    x_1 = (_e166 + 1i);\n                }\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e168 = y_1;\n            y_1 = (_e168 + 1i);\n        }\n    }\n    let _e170 = nearestAt;\n    let _e173 = ((_e170 * 2f) - vec2(1f));\n    let _e174 = depth_1;\n    clip = vec4<f32>(_e173.x, _e173.y, (1f - (_e174 * 2f)), 1f);\n    let _e181 = unnamed.uReprojection;\n    let _e182 = clip;\n    previous_1 = (_e181 * _e182);\n    let _e185 = previous_1[3u];\n    if (_e185 <= 0f) {\n        let _e187 = current_1;\n        fragColor = vec4<f32>(_e187.x, _e187.y, _e187.z, 1f);\n        let _e192 = current_1;\n        param_4 = _e192;\n        let _e193 = freshRecord_u0028_vf3_u003b((&param_4));\n        flickerOut = _e193;\n        let _e194 = metres;\n        flickerMotionOut = vec4<f32>(_e194, 0f, 0f, 0f);\n        return;\n    }\n    let _e196 = vUv_1;\n    let _e197 = previous_1;\n    let _e200 = previous_1[3u];\n    let _e206 = nearestAt;\n    wasUv = (_e196 + ((((_e197.xy / vec2(_e200)) * 0.5f) + vec2(0.5f)) - _e206));\n    let _e210 = wasUv[0u];\n    let _e211 = (_e210 < 0f);\n    phi_589_ = _e211;\n    if !(_e211) {\n        let _e214 = wasUv[0u];\n        phi_589_ = (_e214 > 1f);\n    }\n    let _e217 = phi_589_;\n    phi_596_ = _e217;\n    if !(_e217) {\n        let _e220 = wasUv[1u];\n        phi_596_ = (_e220 < 0f);\n    }\n    let _e223 = phi_596_;\n    phi_603_ = _e223;\n    if !(_e223) {\n        let _e226 = wasUv[1u];\n        phi_603_ = (_e226 > 1f);\n    }\n    let _e229 = phi_603_;\n    if _e229 {\n        let _e230 = current_1;\n        fragColor = vec4<f32>(_e230.x, _e230.y, _e230.z, 1f);\n        let _e235 = current_1;\n        param_5 = _e235;\n        let _e236 = freshRecord_u0028_vf3_u003b((&param_5));\n        flickerOut = _e236;\n        let _e237 = metres;\n        flickerMotionOut = vec4<f32>(_e237, 0f, 0f, 0f);\n        return;\n    }\n    neighbourhood_u0028_vf3_u003b_vf3_u003b((&param_6), (&param_7));\n    let _e239 = param_6;\n    lo_2 = _e239;\n    let _e240 = param_7;\n    hi_2 = _e240;\n    let _e241 = wasUv;\n    param_8 = _e241;\n    let _e242 = historyCatmullRom_u0028_vf2_u003b((&param_8));\n    history_1 = _e242;\n    let _e243 = textureDimensions(uFlicker_t, 0i);\n    size_1 = vec2<i32>(_e243);\n    let _e245 = wasUv;\n    let _e246 = size_1;\n    let _e250 = size_1;\n    was = clamp(vec2<i32>((_e245 * vec2<f32>(_e246))), vec2<i32>(0i, 0i), (_e250 - vec2(1i)));\n    nearest = 1000000000f;\n    n = 0i;\n    loop {\n        let _e254 = n;\n        if (_e254 < 5i) {\n            let _e256 = was;\n            let _e257 = n;\n            if (_e257 == 1i) {\n                local = vec2<i32>(1i, 0i);\n            } else {\n                let _e259 = n;\n                if (_e259 == 2i) {\n                    local_1 = vec2<i32>(-1i, 0i);\n                } else {\n                    let _e261 = n;\n                    if (_e261 == 3i) {\n                        local_2 = vec2<i32>(0i, 1i);\n                    } else {\n                        let _e263 = n;\n                        local_2 = select(vec2<i32>(0i, 0i), vec2<i32>(0i, -1i), vec2((_e263 == 4i)));\n                    }\n                    let _e267 = local_2;\n                    local_1 = _e267;\n                }\n                let _e268 = local_1;\n                local = _e268;\n            }\n            let _e269 = local;\n            at_2 = (_e256 + _e269);\n            let _e271 = at_2;\n            let _e272 = size_1;\n            let _e276 = textureLoad(uFlickerMotion_t, clamp(_e271, vec2<i32>(0i, 0i), (_e272 - vec2(1i))), 0i);\n            stood = _e276.x;\n            let _e278 = stood;\n            if (_e278 > 0f) {\n                let _e280 = nearest;\n                let _e281 = stood;\n                let _e283 = previous_1[3u];\n                nearest = min(_e280, abs((_e281 - _e283)));\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e287 = n;\n            n = (_e287 + 1i);\n        }\n    }\n    let _e289 = was;\n    let _e290 = textureLoad(uFlickerMotion_t, _e289, 0i);\n    motionThere = _e290;\n    let _e291 = nearest;\n    missedAll = (_e291 > 100000000f);\n    let _e294 = unnamed.uAntiFlicker;\n    let _e296 = missedAll;\n    let _e298 = ((_e294 > 0.5f) && !(_e296));\n    phi_740_ = _e298;\n    if _e298 {\n        let _e299 = nearest;\n        let _e301 = motionThere[1u];\n        let _e304 = previous_1[3u];\n        phi_740_ = (_e299 <= ((6f * _e301) + (0.02f * _e304)));\n    }\n    let _e309 = phi_740_;\n    same = _e309;\n    let _e310 = missedAll;\n    if _e310 {\n        local_3 = 0f;\n    } else {\n        let _e312 = motionThere[1u];\n        let _e313 = nearest;\n        let _e315 = motionThere[1u];\n        local_3 = (_e312 + ((_e313 - _e315) * 0.125f));\n    }\n    let _e319 = local_3;\n    swingOut = _e319;\n    let _e320 = current_1;\n    param_9 = _e320;\n    let _e321 = luma_u0028_vf3_u003b((&param_9));\n    seen_1 = _e321;\n    let _e322 = same;\n    if _e322 {\n        let _e323 = was;\n        let _e324 = textureLoad(uFlicker_t, _e323, 0i);\n        local_4 = _e324;\n    } else {\n        let _e325 = current_1;\n        param_10 = _e325;\n        let _e326 = freshRecord_u0028_vf3_u003b((&param_10));\n        local_4 = _e326;\n    }\n    let _e327 = local_4;\n    held = _e327;\n    let _e328 = wasUv;\n    let _e329 = vUv_1;\n    let _e332 = unnamed.uTexel;\n    still = (1f - smoothstep(0.01f, 0.05f, length(((_e328 - _e329) / _e332))));\n    let _e337 = seen_1;\n    let _e339 = held[2u];\n    apart_1 = abs((_e337 - _e339));\n    let _e343 = held[0u];\n    reach = ((6f * _e343) + 0.003921569f);\n    let _e346 = apart_1;\n    let _e347 = reach;\n    within = (_e346 <= _e347);\n    let _e350 = held[3u];\n    let _e352 = within;\n    proven = ((_e350 > 0.75f) && _e352);\n    let _e354 = proven;\n    if _e354 {\n        let _e356 = held[0u];\n        let _e358 = still;\n        local_5 = ((6f * _e356) * _e358);\n    } else {\n        local_5 = 0f;\n    }\n    let _e360 = local_5;\n    widen = _e360;\n    let _e361 = proven;\n    if _e361 {\n        let _e363 = unnamed.uHistoryBlend;\n        let _e364 = still;\n        local_6 = mix(_e363, 0.97f, _e364);\n    } else {\n        let _e367 = unnamed.uHistoryBlend;\n        local_6 = _e367;\n    }\n    let _e368 = local_6;\n    blend = _e368;\n    let _e369 = lo_2;\n    let _e370 = widen;\n    let _e373 = hi_2;\n    let _e374 = widen;\n    let _e377 = history_1;\n    param_11 = _e377;\n    param_12 = (_e369 - vec3(_e370));\n    param_13 = (_e373 + vec3(_e374));\n    let _e378 = clipToNeighbourhood_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_11), (&param_12), (&param_13));\n    bounded = _e378;\n    let _e380 = held[1u];\n    sum_1 = _e380;\n    let _e382 = held[2u];\n    mean_1 = _e382;\n    let _e383 = within;\n    if _e383 {\n        let _e385 = held[3u];\n        local_7 = _e385;\n    } else {\n        local_7 = 0f;\n    }\n    let _e386 = local_7;\n    repeated = _e386;\n    let _e388 = unnamed.uPeriodStart;\n    if (_e388 > 0.5f) {\n        let _e390 = sum_1;\n        param_14 = _e390;\n        let _e391 = mean_1;\n        param_15 = _e391;\n        let _e392 = repeats_u0028_f1_u003b_f1_u003b((&param_14), (&param_15));\n        if (_e392 > 0.5f) {\n            let _e394 = repeated;\n            local_8 = min(1f, (_e394 + 0.5f));\n        } else {\n            local_8 = 0f;\n        }\n        let _e397 = local_8;\n        repeated = _e397;\n        let _e398 = sum_1;\n        mean_1 = _e398;\n        sum_1 = 0f;\n    }\n    let _e400 = held[0u];\n    let _e401 = apart_1;\n    let _e403 = held[0u];\n    let _e407 = sum_1;\n    let _e408 = seen_1;\n    let _e411 = mean_1;\n    let _e412 = repeated;\n    let _e413 = still;\n    flickerOut = vec4<f32>((_e400 + ((_e401 - _e403) * 0.125f)), (_e407 + (_e408 * 0.125f)), _e411, (_e412 * _e413));\n    let _e416 = metres;\n    let _e417 = swingOut;\n    flickerMotionOut = vec4<f32>(_e416, _e417, 0f, 0f);\n    let _e419 = current_1;\n    let _e420 = bounded;\n    let _e421 = blend;\n    let _e423 = mix(_e419, _e420, vec3(_e421));\n    fragColor = vec4<f32>(_e423.x, _e423.y, _e423.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> FragmentOutput {\n    vUv_1 = vUv;\n    main_1();\n    let _e5 = fragColor;\n    let _e6 = flickerOut;\n    let _e7 = flickerMotionOut;\n    return FragmentOutput(_e5, _e6, _e7);\n}\n";
 /**
  * What the transform assigned, so the renderer binds the same numbers.
  *
@@ -13,20 +13,35 @@ export const TEMPORAL_RESOLVE_FRAG_WGSL = "struct Uniforms {\n    uReprojection:
 export const TEMPORALRESOLVE_BINDINGS = {
     "TEMPORAL_RESOLVE_FRAG": {
         "uniforms": 1,
-        "uniformSize": 80,
+        "uniformSize": 112,
         "fields": {
-            "uReprojection": {
+            "uDepthToViewZ": {
                 "offset": 0,
+                "size": 16,
+                "type": "vec4"
+            },
+            "uAntiFlicker": {
+                "offset": 16,
+                "size": 4,
+                "type": "float"
+            },
+            "uReprojection": {
+                "offset": 32,
                 "size": 64,
                 "type": "mat4"
             },
             "uTexel": {
-                "offset": 64,
+                "offset": 96,
                 "size": 8,
                 "type": "vec2"
             },
+            "uPeriodStart": {
+                "offset": 104,
+                "size": 4,
+                "type": "float"
+            },
             "uHistoryBlend": {
-                "offset": 72,
+                "offset": 108,
                 "size": 4,
                 "type": "float"
             }
@@ -42,10 +57,20 @@ export const TEMPORALRESOLVE_BINDINGS = {
                 "sampler": 35,
                 "type": "sampler2D"
             },
-            "uDepth": {
+            "uFlicker": {
                 "texture": 36,
                 "sampler": 37,
                 "type": "sampler2D"
+            },
+            "uFlickerMotion": {
+                "texture": 38,
+                "sampler": 39,
+                "type": "sampler2D"
+            },
+            "uDepth": {
+                "texture": 40,
+                "sampler": 41,
+                "type": "sampler2D"
             }
         }
     }

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