@photivra/engine 2.8.1 → 2.10.0

package/dist/facade/expected-signal.js

@@ -11,23 +11,92 @@ const CACHE_LIMIT = 1 << 22;
 /** Largest band of looked-up lattice materials per group, in lattice points (a band that would be larger restarts at the window). */
 const BAND_LIMIT = 1 << 22;
 /**
- * Expected photo electrons per site: μ_c(i, j) = Σ_o w_o Σ_λ A_c(λ) Σ_t K_λ(t)·L(p_o(i, j) − t, λ), where p_o is the
- * query point of offset o and K the diffraction kernel (a single unit tap without diffraction). This is the sum the
- * facade's environment chain forms for a still, rectilinear, distortion-free planar scene, where the
- * radiance-to-irradiance factor is the same at every site (docs/DISPLAY_VIEW.md, "Expected signal").
- *
- * With diffraction, offsets that share a fractional shift read one lattice, and their kernels are combined in advance:
- * C_c(d) = Σ_members w·Σ_λ A_c(λ)·K_λ(t)·L(λ) over the taps t that reach lattice offset d. A neutral material's radiance
- * is its reflectance times the white radiance, so all neutral materials share one combined kernel per channel.
+ * Lattice-row ring (refinement windows): rows kept per group, the tallest band that uses it, and the columns kept beyond each
+ * raster edge (kernel radius, demosaic reach and query offsets; columns beyond it are looked up directly).
  */
-export function createDisplayViewExpectedSignal(input) {
-    const W = input.nativeWidth, H = input.nativeHeight, g = 2 / input.outputWidth, nodes = input.wavelengthsNm.length;
-    const R = input.kernels ? input.kernels.radius : 0, size = 2 * R + 1;
-    if (input.kernels && input.kernels.perNode.length !== nodes)
-        throw new InvalidConfigurationError("Display view kernels must match the spectral nodes.");
-    if (!input.kernels && !input.queryPoint)
-        throw new InvalidConfigurationError("Display view needs the environment query points without diffraction.");
-    const A = input.electronsPerRadiance, scene = input.scene, offsets = input.offsets, channelAt = input.channelAt;
+const LATTICE_RING_ROWS = 128, LATTICE_RING_MAXIMUM_BAND_ROWS = 64, LATTICE_RING_MARGIN = 64;
+const PREPARED = new WeakMap();
+/** Chart-material tables kept by content across input objects (#449), least recently used first. */
+export const EXPECTED_SIGNAL_TABLE_CACHE_SIZE = 4;
+const tableCache = [];
+let tableBuilds = 0, tableHits = 0;
+/** Internal test hook: the kept table entries, and the tables built and found by content so far. */
+export function expectedSignalTableCacheState() { return { size: tableCache.length, builds: tableBuilds, hits: tableHits }; }
+/** Internal test hook: forgets the tables kept by content (inputs already prepared keep theirs). */
+export function clearExpectedSignalTableCache() { tableCache.length = 0; }
+/**
+ * Every number the tables read, with the lengths that delimit them, as the bits of doubles (so -0, NaN and every digit are kept
+ * apart): the spectral nodes, the three channel responses, the offsets, the kernel radius and taps, each material's reflectance or
+ * radiance, and the white radiance. Undefined for radiance scenes, whose tables are not kept by content.
+ */
+function tableSignature(input) {
+    const scene = input.scene;
+    if (scene.kind !== "materials")
+        return undefined;
+    const values = [];
+    const push = (a) => { values.push(a.length); for (let i = 0; i < a.length; i++)
+        values.push(a[i]); };
+    push(input.wavelengthsNm);
+    values.push(input.electronsPerRadiance.length);
+    for (const a of input.electronsPerRadiance)
+        push(a);
+    values.push(input.offsets.length);
+    for (const o of input.offsets)
+        values.push(o.x, o.y, o.weight);
+    if (input.kernels) {
+        values.push(1, input.kernels.radius, input.kernels.perNode.length);
+        for (const k of input.kernels.perNode)
+            push(k);
+    }
+    else
+        values.push(0);
+    values.push(scene.materials.length);
+    for (const m of scene.materials)
+        if ("neutral" in m)
+            values.push(0, m.neutral);
+        else {
+            values.push(1);
+            push(m.radiance);
+        }
+    push(scene.whiteRadiance);
+    return new Uint32Array(Float64Array.from(values).buffer);
+}
+function sameBits(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+function prepareSignal(input) {
+    const signature = tableSignature(input);
+    let tables;
+    if (signature) {
+        const at = tableCache.findIndex((entry) => sameBits(entry.signature, signature));
+        if (at >= 0) {
+            const [entry] = tableCache.splice(at, 1);
+            tableCache.push(entry);
+            tables = entry.tables;
+            tableHits++;
+        }
+    }
+    if (!tables) {
+        tables = buildTables(input);
+        tableBuilds++;
+        if (signature) {
+            tableCache.push({ signature, tables });
+            while (tableCache.length > EXPECTED_SIGNAL_TABLE_CACHE_SIZE)
+                tableCache.shift();
+        }
+    }
+    const prepared = { tables, rings: tables.groups.map(() => undefined) };
+    PREPARED.set(input, prepared);
+    return prepared;
+}
+function buildTables(input) {
+    const nodes = input.wavelengthsNm.length, R = input.kernels ? input.kernels.radius : 0, size = 2 * R + 1;
+    const A = input.electronsPerRadiance, scene = input.scene, offsets = input.offsets;
     const kernelAt = (node, t) => (input.kernels ? input.kernels.perNode[node][t] : 1);
     // Materials: neutral ones by reflectance, spectral ones by index.
     let reflectance = new Float64Array(0), spectralIndex = new Int32Array(0);
@@ -35,11 +104,12 @@ export function createDisplayViewExpectedSignal(input) {
     if (scene.kind === "materials") {
         reflectance = new Float64Array(scene.materials.length);
         spectralIndex = new Int32Array(scene.materials.length).fill(-1);
+        // A copy of each spectral radiance: the tables may outlive the input and serve other inputs of the same content.
         scene.materials.forEach((m, index) => { if ("neutral" in m)
             reflectance[index] = m.neutral;
         else {
             spectralIndex[index] = spectral.length;
-            spectral.push(m.radiance);
+            spectral.push(Float64Array.from(m.radiance));
         } });
     }
     // Offsets grouped by fractional shift: offsets that differ by whole sites share one lattice.
@@ -49,7 +119,7 @@ export function createDisplayViewExpectedSignal(input) {
         const fx = frac(o.x), fy = frac(o.y), ix = Math.round(o.x - fx), iy = Math.round(o.y - fy);
         let group = groups.find((q) => Math.abs(q.fx - fx) <= OFFSET_TOLERANCE && Math.abs(q.fy - fy) <= OFFSET_TOLERANCE);
         if (!group) {
-            group = { fx, fy, members: [], minIx: ix, maxIx: ix, minIy: iy, maxIy: iy, cw: 0, ch: 0, neutral: [], spectral: [], perNode: [], cache: new Int32Array(0), cx0: 0, cy0: 0, cpw: 0, cph: 0 };
+            group = { fx, fy, members: [], minIx: ix, maxIx: ix, minIy: iy, maxIy: iy, cw: 0, ch: 0, neutral: [], spectral: [], perNode: [] };
             groups.push(group);
         }
         group.members.push({ ix, iy, weight: o.weight });
@@ -92,6 +162,48 @@ export function createDisplayViewExpectedSignal(input) {
         s += A[c][n] * scene.whiteRadiance[n]; return s; }) : [];
     const spectralDirect = [0, 1, 2].map((c) => spectral.map((radiance) => { let s = 0; for (let n = 0; n < nodes; n++)
         s += A[c][n] * radiance[n]; return s; }));
+    const uniformSite = scene.kind === "materials" && input.kernels ? [0, 1, 2].map((c) => Float64Array.from(scene.materials, (_, m) => {
+        const si = spectralIndex[m];
+        let sum = 0;
+        for (const group of groups) {
+            const nk = group.neutral[c], sk = si < 0 ? nk : group.spectral[c][si];
+            for (let t = 0; t < group.cw * group.ch; t++)
+                sum += si < 0 ? reflectance[m] * nk[t] : sk[t];
+        }
+        return sum;
+    })) : [];
+    // Frozen records: a render copies each group before it gives it a window (see createDisplayViewExpectedSignal).
+    for (const group of groups)
+        Object.freeze(group);
+    return Object.freeze({ reflectance, spectralIndex, spectral, groups, neutralDirect, spectralDirect, uniformSite });
+}
+/**
+ * Expected photo electrons per site: μ_c(i, j) = Σ_o w_o Σ_λ A_c(λ) Σ_t K_λ(t)·L(p_o(i, j) − t, λ), where p_o is the
+ * query point of offset o and K the diffraction kernel (a single unit tap without diffraction). This is the sum the
+ * facade's environment chain forms for a still, rectilinear, distortion-free planar scene, where the
+ * radiance-to-irradiance factor is the same at every site (docs/DISPLAY_VIEW.md, "Expected signal").
+ *
+ * With diffraction, offsets that share a fractional shift read one lattice, and their kernels are combined in advance:
+ * C_c(d) = Σ_members w·Σ_λ A_c(λ)·K_λ(t)·L(λ) over the taps t that reach lattice offset d. A neutral material's radiance
+ * is its reflectance times the white radiance, so all neutral materials share one combined kernel per channel.
+ *
+ * `spanColumns`: how many native columns the render's windows move across beyond one window's width (a filled band is never
+ * built wider). Only a speed hint: a window past it rebuilds its band, with the same values.
+ */
+export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
+    const W = input.nativeWidth, H = input.nativeHeight, g = 2 / input.outputWidth, nodes = input.wavelengthsNm.length;
+    const R = input.kernels ? input.kernels.radius : 0;
+    if (input.kernels && input.kernels.perNode.length !== nodes)
+        throw new InvalidConfigurationError("Display view kernels must match the spectral nodes.");
+    if (!input.kernels && !input.queryPoint)
+        throw new InvalidConfigurationError("Display view needs the environment query points without diffraction.");
+    const A = input.electronsPerRadiance, scene = input.scene, offsets = input.offsets, channelAt = input.channelAt;
+    // The request's tables (materials, lattice groups, combined kernels, per-material sums) are the same for every render of a
+    // prepared view, which passes the same input object: computed once per input. Each render gets its own groups' window caches.
+    // Chart-material tables are also shared by inputs of the same content (#449): each render gets its own groups' window state.
+    const prepared = PREPARED.get(input) ?? prepareSignal(input);
+    const { reflectance, spectralIndex, spectral, neutralDirect, spectralDirect, uniformSite } = prepared.tables;
+    const groups = prepared.tables.groups.map((group) => ({ ...group, cache: new Int32Array(0), cx0: 0, cy0: 0, cpw: 0, cph: 0 }));
     let lookups = 0;
     const point = new Float64Array(2);
     const materialSignalDirect = (m, c) => {
@@ -100,15 +212,21 @@ export function createDisplayViewExpectedSignal(input) {
             throw new InvalidConfigurationError("Unknown chart material.");
         return si < 0 ? reflectance[m] * neutralDirect[c] : spectralDirect[c][si];
     };
-    /** Without diffraction: one site from the environment's own query points. */
+    /**
+     * Without diffraction: one site from the environment's own query points. Also sets lastMaterial: the chart material every
+     * query point read, or −1 when they read more than one (or the scene is a radiance scene). A site whose points all read
+     * material m sums the same operands in the same order as every other such site of its channel, so it holds the same value.
+     */
     function directSite(x, y) {
         const c = channelAt(x, y);
-        let sum = 0;
+        let sum = 0, uniform = -1;
         for (let o = 0; o < offsets.length; o++) {
             input.queryPoint(x, y, o, point);
             let value;
             if (scene.kind === "materials") {
-                value = materialSignalDirect(scene.materialAt(point[0], point[1]), c);
+                const m = scene.materialAt(point[0], point[1]);
+                uniform = o === 0 || uniform === m ? m : -2;
+                value = materialSignalDirect(m, c);
                 lookups++;
             }
             else {
@@ -119,6 +237,7 @@ export function createDisplayViewExpectedSignal(input) {
             }
             sum += offsets[o].weight * value;
         }
+        lastMaterial = uniform < 0 ? -1 : uniform;
         return sum;
     }
     // Lattice point (p, q) of a group: the facade's lattice formula (createDiffractedPlanarProvider).
@@ -190,24 +309,32 @@ export function createDisplayViewExpectedSignal(input) {
     // kernelSite, so it is bit-identical. The scene lookup count stays the count kernelSite's lazy window cache makes (each
     // cache point a computed site reads counts once per window, points outside the cache once per read): the rectangles of
     // the sites computed in a window are counted when the window closes (windowLookups).
-    const uniformSite = scene.kind === "materials" && input.kernels ? [0, 1, 2].map((c) => Float64Array.from(scene.materials, (_, m) => {
-        const si = spectralIndex[m];
-        let sum = 0;
-        for (const group of groups) {
-            const nk = group.neutral[c], sk = si < 0 ? nk : group.spectral[c][si];
-            for (let t = 0; t < group.cw * group.ch; t++)
-                sum += si < 0 ? reflectance[m] * nk[t] : sk[t];
-        }
-        return sum;
-    })) : [];
     const allNeutral = spectral.length === 0;
     const bands = groups.map(() => ({ x0: 0, y0: 0, rows: 0, capacity: 0, filled: 0, material: new Int32Array(0), reflectance: new Float64Array(0),
         changeLeft: new Int32Array(0), changeUp: new Int32Array(0), v: new Float64Array(0) }));
+    // Lattice rows of material indices per group, kept across windows (filled windows only): rows LATTICE_RING_ROWS apart share a
+    // slot; columns from −LATTICE_RING_MARGIN. Int16 when every index fits (about 3 MB for four groups of a 6000-site row). A
+    // lattice point's material depends only on the input, so the rings are kept per input object, across its renders (not with
+    // the tables kept by content: they depend on `materialAt` and the raster).
+    const ringWide = scene.kind === "materials" && scene.materials.length <= 32767;
+    const rings = prepared.rings;
+    function latticeRing(g) {
+        let ring = rings[g];
+        if (!ring) {
+            const width = W + 2 * LATTICE_RING_MARGIN, size = LATTICE_RING_ROWS * width;
+            ring = rings[g] = { width, material: ringWide ? new Int16Array(size) : new Int32Array(size), rowId: new Int32Array(LATTICE_RING_ROWS).fill(-2147483648) };
+        }
+        return ring;
+    }
     /** Makes the band of group g cover lattice columns [x0, x1) of rows [y0, y0 + rows), extending it to the right when it can. */
     function coverBand(g, x0, x1, y0, rows) {
         const group = groups[g], band = bands[g], materials = scene;
-        if (!(band.rows === rows && band.y0 === y0 && x0 >= band.x0 && x1 - band.x0 <= band.capacity)) {
-            const capacity = Math.max(x1 - x0, Math.min(Math.floor(BAND_LIMIT / rows), W + 2 * (x1 - x0)));
+        if (!(y0 >= band.y0 && y0 + rows <= band.y0 + band.rows && x0 >= band.x0 && x1 - band.x0 <= band.capacity)) {
+            // A band with the ring is built twice as tall, so the next display rows' windows (a few lattice rows lower) reuse its
+            // filled columns; a lattice point's material and the change counts inside a rectangle do not depend on the band's origin.
+            if (rows <= LATTICE_RING_MAXIMUM_BAND_ROWS)
+                rows *= 2;
+            const capacity = Math.max(x1 - x0, Math.min(Math.floor(BAND_LIMIT / rows), W + 2 * (x1 - x0), spanColumns + x1 - x0));
             const size = rows * capacity, tables = (rows + 1) * (capacity + 1);
             band.x0 = x0;
             band.y0 = y0;
@@ -234,10 +361,29 @@ export function createDisplayViewExpectedSignal(input) {
                 band.v[j] = latticeV(group, y0 + j);
         }
         const stride = band.capacity, S1 = stride + 1, material = band.material, left = band.changeLeft, up = band.changeUp;
+        rows = band.rows;
+        y0 = band.y0;
+        const ring = rows <= 2 * LATTICE_RING_MAXIMUM_BAND_ROWS ? latticeRing(g) : undefined;
         for (let i = band.filled; i < x1 - band.x0; i++) {
-            const u = latticeU(group, band.x0 + i);
+            const p = band.x0 + i, u = latticeU(group, p), column = p + LATTICE_RING_MARGIN;
             for (let j = 0; j < rows; j++) {
-                const m = materials.materialAt(u, band.v[j]);
+                let m;
+                if (ring && column >= 0 && column < ring.width) {
+                    // A lattice point's material is a function of the point alone, so one looked up for an earlier window (the rows a
+                    // display row shares with the next) is the same material; the ring only spares the repeated lookup.
+                    const q = y0 + j, slot = q & (LATTICE_RING_ROWS - 1), index = slot * ring.width + column;
+                    if (ring.rowId[slot] !== q) {
+                        ring.rowId[slot] = q;
+                        ring.material.fill(-1, slot * ring.width, (slot + 1) * ring.width);
+                    }
+                    m = ring.material[index];
+                    if (m < 0) {
+                        m = materials.materialAt(u, band.v[j]);
+                        ring.material[index] = m;
+                    }
+                }
+                else
+                    m = materials.materialAt(u, band.v[j]);
                 if (spectralIndex[m] === undefined)
                     throw new InvalidConfigurationError("Unknown chart material.");
                 material[j * stride + i] = m;
@@ -355,8 +501,9 @@ export function createDisplayViewExpectedSignal(input) {
         return v;
     }
     // Without diffraction (#392): site values persist across windows the same way, in their own ring (a site's value does not
-    // depend on the window). A ring hit counts the lookups directSite would have made, so `lookups` is unchanged.
-    let directRows = 0, directOn = false, directRing = new Float64Array(0), directRowId = new Int32Array(0);
+    // depend on the window). A ring hit counts the lookups directSite would have made, so `lookups` is unchanged. The site's
+    // material (directSite's lastMaterial) is kept beside its value, so the display view's one-material memo applies (#444).
+    let directRows = 0, directOn = false, directRing = new Float64Array(0), directRowId = new Int32Array(0), directRingMaterial = new Int32Array(0);
     const directLookups = offsets.length * (scene.kind === "materials" ? 1 : nodes);
     function directRead(x, y) {
         const slot = y & (directRows - 1), q = slot * W + x;
@@ -364,6 +511,7 @@ export function createDisplayViewExpectedSignal(input) {
             const v = directRing[q];
             if (v === v) {
                 lookups += directLookups;
+                lastMaterial = directRingMaterial[q];
                 return v;
             }
         }
@@ -373,14 +521,17 @@ export function createDisplayViewExpectedSignal(input) {
         }
         const v = directSite(x, y);
         directRing[q] = v;
+        directRingMaterial[q] = lastMaterial;
         return v;
     }
     /** A site not in the window's site cache: from a ring, a filled window without the ring, the lazy window caches, or uncached. */
     function siteMiss(x, y, i, j, cached) {
         if (directOn) {
             const v = directRead(x, y);
-            if (cached)
+            if (cached) {
                 siteCache[j * sw + i] = v;
+                windowMaterial[j * sw + i] = lastMaterial;
+            }
             return v;
         }
         if (ringOn) {
@@ -391,23 +542,114 @@ export function createDisplayViewExpectedSignal(input) {
             const v = ringRead(x, y, i, j);
             siteCache[j * sw + i] = v;
             windowMaterial[j * sw + i] = lastMaterial;
+            markFilled(i, j);
             return v;
         }
         if (filled && !cached)
             outsideRead(i, j);
         const v = filled ? filledSite(x, y, i, j) : input.kernels ? kernelSite(x, y) : directSite(x, y);
-        if (cached)
+        if (cached) {
             siteCache[j * sw + i] = v;
+            if (filled)
+                markFilled(i, j);
+        }
         return v;
     }
     /**
      * Lattice points of the closing window that kernelSite's lazy cache would have looked up: per group, the window cache points
      * covered by the rectangles of the computed sites (the site cache's filled entries and the outside sites), a box dilation.
+     * A group's count depends only on the computed sites and its geometry (cw, ch, cpw, cph), so a group shaped like an
+     * earlier one takes that group's count (the app's Quality groups all have one shape).
      */
+    const groupTotals = new Float64Array(groups.length);
+    function sameGeometry(g) {
+        const group = groups[g];
+        for (let h = 0; h < g; h++) {
+            const o = groups[h];
+            if (o.cw === group.cw && o.ch === group.ch && o.cpw === group.cpw && o.cph === group.cph)
+                return h;
+        }
+        return -1;
+    }
     function windowLookups() {
         let total = 0;
-        for (const group of groups) {
-            const cw = group.cw, ch = group.ch, cpw = group.cpw, cph = group.cph, ew = cpw + cw - 1, eh = cph + ch - 1;
+        if (outsideSites.length === 0 && filledCount === 0)
+            return 0;
+        if (outsideSites.length === 0 && filledCount === sw * sh) {
+            // Every site computed (each once) and none outside: the marks at (i + cw − 1, j + ch − 1) cover cache columns
+            // 0 … sw + cw − 2 and rows 0 … sh + ch − 2, the whole cpw × cph cache of every group.
+            for (const group of groups)
+                total += group.cpw * group.cph;
+            return total;
+        }
+        if (outsideSites.length === 0 && sw <= 31) {
+            // Computed sites as a bit mask per window row. Cache point (ci, cj) is covered when a computed site (i, j) has
+            // i ≤ ci < i + cw and j ≤ cj < j + ch; a union of dilations is the dilation of the union, so per cache row the
+            // covered columns are the dilation of the OR of the masks of window rows cj − ch + 1 … cj. That OR is a prefix OR
+            // when the rows start at fy0 and a suffix OR when they end at fy1 (OR is associative and commutative).
+            if (prefixOr.length < sh) {
+                prefixOr = new Int32Array(sh);
+                suffixOr = new Int32Array(sh);
+            }
+            for (let j = fy0, m = 0; j <= fy1; j++) {
+                m |= rowMask[j];
+                prefixOr[j] = m;
+            }
+            for (let j = fy1, m = 0; j >= fy0; j--) {
+                m |= rowMask[j];
+                suffixOr[j] = m;
+            }
+            for (let g = 0; g < groups.length; g++) {
+                const same = sameGeometry(g);
+                if (same >= 0) {
+                    total += groupTotals[same];
+                    groupTotals[g] = groupTotals[same];
+                    continue;
+                }
+                const group = groups[g], cw = group.cw, ch = group.ch, cpw = group.cpw, cph = group.cph, last = Math.min(cph - 1, fy1 + ch - 1), before = total;
+                let previous = -1, width = 0;
+                for (let cj = fy0; cj <= last; cj++) {
+                    let m = 0;
+                    const a = Math.max(fy0, cj - ch + 1), b = Math.min(fy1, cj);
+                    if (a === fy0)
+                        m = prefixOr[b];
+                    else if (b === fy1)
+                        m = suffixOr[a];
+                    else
+                        for (let j = a; j <= b; j++)
+                            m |= rowMask[j];
+                    if (m !== previous) {
+                        previous = m;
+                        width = 0;
+                        let end = -1;
+                        for (let i = 0; m >>> i !== 0; i++) {
+                            if (((m >>> i) & 1) === 0)
+                                continue;
+                            const to = Math.min(i + cw - 1, cpw - 1);
+                            if (i > end)
+                                width += to - i + 1;
+                            else if (to > end)
+                                width += to - end;
+                            if (to > end)
+                                end = to;
+                        }
+                    }
+                    total += width;
+                }
+                groupTotals[g] = total - before;
+            }
+            return total;
+        }
+        for (let g = 0; g < groups.length; g++) {
+            // The marks are the computed sites shifted by (cw − 1, ch − 1), so the count depends on the group's geometry only.
+            const same = sameGeometry(g);
+            if (same >= 0) {
+                total += groupTotals[same];
+                groupTotals[g] = groupTotals[same];
+                continue;
+            }
+            const group = groups[g], cw = group.cw, ch = group.ch, cpw = group.cpw, cph = group.cph, ew = cpw + cw - 1, eh = cph + ch - 1, before = total;
+            groupTotals[g] = 0;
             // Top-left marks in extended coordinates (window coordinates + (cw − 1, ch − 1)), and their bounding box.
             if (marks.length < ew * eh) {
                 marks = new Uint8Array(ew * eh);
@@ -462,22 +704,63 @@ export function createDisplayViewExpectedSignal(input) {
                         total++;
                 }
             }
+            groupTotals[g] = total - before;
         }
         return total;
     }
     let sx0 = 0, sy0 = 0, sw = 0, sh = 0, siteCache = new Float64Array(0);
+    // The computed entries of a filled window's site cache (windowLookups): their count, bounding box and a bit mask per row
+    // (columns below 31).
+    let filledCount = 0, fx0 = 0, fx1 = -1, fy0 = 0, fy1 = -1;
+    let rowMask = new Int32Array(0), prefixOr = new Int32Array(0), suffixOr = new Int32Array(0);
+    function markFilled(i, j) {
+        if (i < 31)
+            rowMask[j] = rowMask[j] | (1 << i);
+        if (filledCount++ === 0) {
+            fx0 = fx1 = i;
+            fy0 = fy1 = j;
+            return;
+        }
+        if (i < fx0)
+            fx0 = i;
+        else if (i > fx1)
+            fx1 = i;
+        if (j < fy0)
+            fy0 = j;
+        else if (j > fy1)
+            fy1 = j;
+    }
     const pilotNode = input.wavelengthsNm[Math.floor(nodes / 2)];
     return {
         get lookups() { return lookups + (filled ? windowLookups() : 0); },
         get uniformMaterial() { return lastMaterial; },
-        get tracksMaterial() { return ringOn; },
+        // Chart materials are tracked on the filled path and, without diffraction, on the direct ring (radiance scenes never).
+        get tracksMaterial() { return ringOn || (directOn && scene.kind === "materials"); },
         get cachesSites() { return sw > 0; },
+        get marksReads() { return filled; },
+        markReads(xs, ys, values, materials, count) {
+            for (let n = 0; n < count; n++) {
+                const i = xs[n] - sx0, j = ys[n] - sy0;
+                if (!(i >= 0 && j >= 0 && i < sw && j < sh))
+                    continue;
+                const w = j * sw + i;
+                if (siteCache[w] === siteCache[w])
+                    continue;
+                // As siteMiss for a site inside a filled window: the computed site is marked (windowLookups counts from the marks)
+                // and its material kept.
+                siteCache[w] = values[n];
+                windowMaterial[w] = materials[n];
+                markFilled(i, j);
+            }
+        },
         window(x0, y0, x1, y1) {
             if (filled)
                 lookups += windowLookups();
             filled = false;
             ringOn = false;
             outsideSites = [];
+            filledCount = 0;
+            rowMask.fill(0, 0, sh);
             sx0 = x0;
             sy0 = y0;
             sw = Math.max(0, x1 - x0);
@@ -488,6 +771,8 @@ export function createDisplayViewExpectedSignal(input) {
             }
             if (siteCache.length < sw * sh)
                 siteCache = new Float64Array(sw * sh);
+            if (rowMask.length < sh)
+                rowMask = new Int32Array(sh);
             siteCache.fill(NaN, 0, sw * sh);
             if (!input.kernels) {
                 // A ring of at least twice the window's rows keeps the rows of the previous display row's windows.
@@ -499,9 +784,12 @@ export function createDisplayViewExpectedSignal(input) {
                         directRows = rows;
                         directRing = new Float64Array(rows * W).fill(NaN);
                         directRowId = new Int32Array(rows).fill(-1);
+                        directRingMaterial = new Int32Array(rows * W);
                     }
                 }
                 directOn = sh > 0 && directRows >= 2 * sh;
+                if (directOn && windowMaterial.length < sw * sh)
+                    windowMaterial = new Int32Array(sw * sh);
                 return;
             }
             for (const group of groups) {
@@ -555,7 +843,7 @@ export function createDisplayViewExpectedSignal(input) {
             if (cached) {
                 const w = j * sw + i, v = siteCache[w];
                 if (v === v) {
-                    if (ringOn)
+                    if (ringOn || directOn)
                         lastMaterial = windowMaterial[w];
                     return v;
                 }