@driftengine/core 4.4.0 → 4.4.2

package/dist/render/pointShadowBudget.js

@@ -84,7 +84,8 @@ chronic) {
     return written;
 }
 /**
- * The shaded lights that also cast, in the order they were shaded.
+ * The shaded lights that also cast, each at its own place in the shaded list, and −1 at the place
+ * of a light that does not.
  *
  * `castsShadow: false` says a light is not worth a cubemap. `selectPointLights` honours
  * that when it builds the *eligible* list, and that was taken for the whole promise — but
@@ -96,20 +97,25 @@ chronic) {
  * It showed up as a shadow with nothing to throw it — a lamp that rides the camera
  * declines to cast for exactly that reason, and cast anyway.
  *
- * Writes into `out` and returns how many it wrote; allocation-free, because this runs
+ * **The place is kept rather than the gap closed, because the place is the shader's index.** The
+ * pool publishes each map under its light's position in this list, and the shader reads a light's
+ * shadow at the light's position in the shaded one. Closing the gap made the two numberings
+ * disagree after the first light that declined: every lamp shaded after it was published one
+ * place down, the first on the declining light and each of the rest on its neighbour. A consumer
+ * whose headlights decline, and are nearly always shaded first, could only keep its lamps honest by
+ * dropping the shadows of every lamp ranked after them, and which lamps those were changed as the
+ * car moved.
+ *
+ * Writes into `out` and returns how many places it wrote; allocation-free, because this runs
  * every frame.
  */
 export function selectCastingLights(lights, activeWorldIndices, activeCount, out) {
-    let written = 0;
-    for (let i = 0; i < activeCount && written < out.length; i++) {
+    const count = Math.min(activeCount, out.length);
+    for (let i = 0; i < count; i++) {
         const worldIndex = activeWorldIndices[i] ?? -1;
-        if (worldIndex < 0)
-            continue;
-        if (lights[worldIndex]?.castsShadow === false)
-            continue;
-        out[written++] = worldIndex;
+        out[i] = worldIndex >= 0 && lights[worldIndex]?.castsShadow !== false ? worldIndex : -1;
     }
-    return written;
+    return count;
 }
 /**
  * How many consecutive frames a slot must be stale before it is treated as chronically so.
@@ -171,15 +177,15 @@ export function runPointShadowBakes(pool, lights, facesPerFrame, liveFacesPerFra
          * **The run decays rather than resetting, and it climbs past the threshold before it stops.**
          *
          * A light that wanders on a curve is not stale on *every* frame — near the turning points of
-         * its travel it moves less in a frame than the rebake tolerance, so a run that reset to zero
-         * lost the tracking allowance there and the map dropped back to two faces a frame. The shadow
-         * then travelled smoothly through the fast part of the wander and stepped through the slow
-         * part, which is not motion and not stillness: it reads as a vibration. Reported that way,
-         * against a brazier, once the tracking allowance was in.
+         * its travel it moves less in a frame than the rebake tolerance. When the run decided whether a
+         * wanderer got its whole cube, a run that reset to zero dropped it back to two faces a frame
+         * there, and the shadow stepped through the slow part of the wander: reported as a vibration
+         * against a brazier. Every image-holding map is re-baked whole now, so the run only orders the
+         * queue, and the hysteresis keeps a wanderer behind the lights that settle instead of letting
+         * it jump ahead at every turning point.
          *
-         * So the run is hysteresis. It climbs to twice the threshold, which buys a light that has
-         * earned the allowance three quiet frames before it loses it, and decays one frame at a time
-         * so a light that genuinely settles stops re-baking rather than holding a budget for ever.
+         * It climbs to twice the threshold, which keeps a light chronic for three quiet frames, and
+         * decays one frame at a time so a light that genuinely settles rejoins the ordinary order.
          */
         const previous = scratch.staleRun[slot] ?? 0;
         const run = stale
@@ -192,37 +198,40 @@ export function runPointShadowBakes(pool, lights, facesPerFrame, liveFacesPerFra
     let faces = facesPerFrame;
     let urgentSpent = false;
     /*
-     * **One wandering light finishes its cube in the frame it started it**, the same allowance a
-     * light with no image at all gets, and for a reason that turns out to be the same one: a map
-     * dribbled out at two faces a frame is a map nobody can sample correctly until it lands.
+     * **A map that holds an image is re-baked whole or not at all**, and one being shaded may take a
+     * whole cube a frame outside the budget to make that possible.
      *
-     * A cold light cannot be sampled *at all* until its six faces are in, so it takes the whole
-     * cube at once. A chronically stale one can be sampled throughout and is wrong in a quieter
-     * way: `planBake` pins the origin for the whole of a resumed bake, so six faces spread over
-     * three frames means the published origin steps once every third frame. The shader shoots from
-     * that origin, so the shadow it draws steps with it — reported on a brazier as motion that was
-     * "really fast, not smooth, snappy, and unrealistic", which is a 20 Hz sample of a flame that
-     * wanders about once a second.
+     * Faces land in the layer the shader samples as they are drawn, and `planBake` publishes the
+     * origin they were drawn from only with the last one. So a re-bake spread over frames is a cube
+     * the shader reads from the old origin with part of it drawn from the new one — and a face is a
+     * 90 degree frustum, so the part drawn from somewhere else is a straight-edged quadrilateral of
+     * wrong shadow on the ground under the lamp. With the budget spent elsewhere it could hold for a
+     * second and more. Reported under a brazier as a dark shape that came and went.
      *
-     * Given the cube in one frame the origin moves every frame and the shadow travels instead.
+     * A map with no image yet is not sampled until its sixth face lands (see
+     * `PointShadowSystem.bind`), so it still fills a few faces a frame, and a cold one being shaded
+     * still jumps the queue with all six.
      *
-     * **Bounded to one light, and it has to be.** Eight braziers each taking six passes is the 48
-     * passes and 89 ms `pointShadowFacesPerFrame` exists to prevent. One is the light being shaded
-     * that most recently went stale, which is the one somebody is standing next to; the rest keep
-     * dribbling under the ordinary budget, and their shadows step rather than travel. That is the
-     * right way round: a shadow you are looking at moves, and a shadow across the square does not
-     * cost the frame.
+     * The allowance used to be for a *chronically* stale light only — a wandering flame — whose
+     * dribbled cube published a new origin once every third frame, so its shadow stepped at 20 Hz
+     * where the flame wanders about once a second: reported as motion that was "really fast, not
+     * smooth, snappy, and unrealistic". Any shaded light is owed the same now, because a cube read
+     * part-way is wrong in the same place for the same reason whether or not it will be stale again.
      *
-     * It is spent *after* the cold and settling groups, because `planPointShadowBakes` orders the
-     * chronic ones last — so a light arriving in range still gets its first image ahead of a flame
-     * refining one it already has.
+     * **Bounded to one light, and it has to be.** Eight braziers each taking six passes is the 48
+     * passes and 89 ms `pointShadowFacesPerFrame` exists to prevent. The first in the plan's order
+     * takes it, and `planPointShadowBakes` puts the lights that settled ahead of the ones that never
+     * do, so a flame refining its image cannot hold a correction hostage. The rest keep sampling a
+     * complete image from a few centimetres away until their turn, which is the trade
+     * `pointShadowRebakeDistance` already makes. A warm map, held but not shaded, is re-baked when a
+     * whole cube fits the budget or once it is shaded, and not before.
      *
-     * **What would make it wrong** is a caster set heavy enough that six passes over it does not
-     * fit the frame. Measured against a game whose whole static world is about 8,500 triangles in
-     * a handful of draws; a world an order of magnitude heavier wants `pointShadowFacesPerFrame`
+     * **What would make it wrong** is a caster set heavy enough that six passes over it does not fit
+     * the frame. Measured against a game whose whole static world is about 8,500 triangles in a
+     * handful of draws; a world an order of magnitude heavier wants `pointShadowFacesPerFrame`
      * raised or this given up, and `gpuTiming` is how to tell which.
      */
-    let trackingSpent = false;
+    let refreshSpent = false;
     for (let i = 0; i < planned && faces > 0; i++) {
         const slot = scratch.order[i] ?? -1;
         /*
@@ -235,15 +244,22 @@ export function runPointShadowBakes(pool, lights, facesPerFrame, liveFacesPerFra
         if (light === undefined || map === undefined)
             continue;
         const sampled = slot < pool.sampledCount;
-        const cold = sampled && scratch.ready[slot] === 0;
-        const urgent = cold && !urgentSpent;
-        /* A light being shaded whose map will be stale again next frame however it is served. */
-        const tracking = !cold && sampled && scratch.chronic[slot] === 1 && !trackingSpent;
-        if (urgent)
-            urgentSpent = true;
-        if (tracking)
-            trackingSpent = true;
-        faces -= bake(map, light, staticCasters, urgent || tracking ? faceCount : faces);
+        if (scratch.ready[slot] !== 1) {
+            /* No image to spoil: a few faces a frame, or all six at once for one being shaded. */
+            const urgent = sampled && !urgentSpent;
+            if (urgent)
+                urgentSpent = true;
+            faces -= bake(map, light, staticCasters, urgent ? faceCount : faces);
+            continue;
+        }
+        if (faces >= faceCount) {
+            faces -= bake(map, light, staticCasters, faceCount);
+            continue;
+        }
+        if (!sampled || refreshSpent)
+            continue;
+        refreshSpent = true;
+        faces -= bake(map, light, staticCasters, faceCount);
     }
     /*
      * Live maps contain movers only and are composed with the static maps in the shader. A second

package/dist/render/recon/disocclusion.d.ts

@@ -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.
@@ -38,14 +43,42 @@ export interface DisocclusionParams {
  * normals trusted fully within sixty degrees and not at all past ninety.
  */
 export declare const DEFAULT_DISOCCLUSION: DisocclusionParams;
+/**
+ * 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 declare const PLANAR_FROM = 0.25;
+export declare 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 declare function planarity(before: number, centre: number, after: number): number;
+/**
+ * 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 declare function surfaceSlope(before: number, centre: number, after: number): number;
 /**
  * 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 declare function disocclusionWeight(currDepth: number, histDepth: number, motionLength: number, normalDot: number, params: DisocclusionParams): number;
+export declare function disocclusionWeight(currDepth: number, histDepth: number, motionLength: number, normalDot: number, params: DisocclusionParams, slope?: number): number;
 /**
  * The world position a depth stands for: `(u, v, clipDepth)` through the inverse view-projection,
  * in whatever depth convention that matrix was built for. Returns false where the matrix has no

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/ambientOcclusion.d.ts

@@ -24,7 +24,8 @@
  * wherever the depth test cuts the window short, as a dotted line along every edge.
  */
 /**
- * The estimate. Writes one channel: 1 is open sky, 0 is fully enclosed.
+ * The estimate. Writes one channel at `AO_STORE`: that is open sky, 0 is fully enclosed, and the
+ * second axis of the blur decodes it.
  *
  * **Horizons, not neighbours: ground-truth ambient occlusion (Jimenez et al. 2016).** Each pixel
  * walks two lines across the screen, both ways, and keeps the highest thing it can see along each
@@ -62,3 +63,40 @@ export declare function gtaoArc(h0: number, h1: number, normal: number): number;
 export declare function nextHorizon(horizon: number, cosine: number): number;
 /** The shader's thickness heuristic. See `AO_THIN` inside `AO_FRAG`. */
 export declare const AO_THIN = 0.2;
+/**
+ * What the estimate is multiplied by before it is stored, and divided by once the blur is done.
+ *
+ * **Half, because an unblurred estimate is allowed past one.** A pixel's two lines see a plane
+ * turned away from the eye from two directions, and the closed form credits one of them more than
+ * the whole sky and the other less: it is the average over every turn that is exactly one, and the
+ * average is what the blur is for. Stored as it came, an eight-bit target clipped every turn above
+ * one before the blur could average it, and every surface seen edge on came back a few percent
+ * shaded with nothing on it. A line reaches π/2 at most, so half fits the whole range.
+ *
+ * What it gives up is one bit of the intermediate: steps of 1/128 rather than 1/256 until the
+ * second axis decodes, which the eight taps a pixel averages carry below what a frame can show.
+ */
+export declare const AO_STORE = 0.5;
+/** How far a neighbour may sit from this pixel's surface, as a fraction of its distance. */
+export declare const AO_BLUR_DEPTH_TOLERANCE = 0.02;
+/**
+ * The blur's weight for a neighbour `offset` pixels along the axis, from view depths: this pixel's
+ * own, the two either side of it, and the neighbour's. The shader's lines written out again.
+ *
+ * **The neighbour is compared with this pixel's plane, not with this pixel's depth.** Comparing
+ * depths refused every neighbour of a surface seen edge on: a floor forty metres out changes its
+ * depth by four percent a row, twice the tolerance, so the pass down the frame kept the centre alone
+ * and left the rotation tile's rows standing — four-pixel stripes across every ramp and far floor,
+ * reported as strips on a track. On a plane 1/z is affine in the screen, so one step of it predicts
+ * the plane's depth at every tap exactly, and a tap is refused only for leaving the plane.
+ *
+ * The step is taken from whichever neighbour is closer to the centre in 1/z. At a silhouette that is
+ * the one on this pixel's own side, so the far surface cannot bend the prediction toward it; on a
+ * plane the two agree to a quantisation step, which moves a weight by nothing a frame shows. What it
+ * gives up is a crease: past the fold between a floor and a wall the prediction runs on along the
+ * floor, so the wall's taps fade out over the tolerance rather than being kept.
+ *
+ * **Written here rather than in the shader**, because a comment inside the GLSL is part of the string
+ * a consumer ships.
+ */
+export declare function blurWeight(centre: number, before: number, after: number, neighbour: number, offset: number): number;