@photivra/engine 2.6.0 → 2.7.0

package/dist/facade/display-view.js

@@ -390,8 +390,35 @@ export function createDisplayViewExpectedSignal(input) {
         ringMaterial[q] = lastMaterial;
         return v;
     }
-    /** A site not in the window's site cache: from the ring, a filled window without the ring, the lazy window caches, or uncached. */
+    // 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);
+    const directLookups = offsets.length * (scene.kind === "materials" ? 1 : nodes);
+    function directRead(x, y) {
+        const slot = y & (directRows - 1), q = slot * W + x;
+        if (directRowId[slot] === y) {
+            const v = directRing[q];
+            if (v === v) {
+                lookups += directLookups;
+                return v;
+            }
+        }
+        else {
+            directRowId[slot] = y;
+            directRing.fill(NaN, slot * W, (slot + 1) * W);
+        }
+        const v = directSite(x, y);
+        directRing[q] = v;
+        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)
+                siteCache[j * sw + i] = v;
+            return v;
+        }
         if (ringOn) {
             if (!cached) {
                 outsideRead(i, j);
@@ -480,6 +507,7 @@ export function createDisplayViewExpectedSignal(input) {
         get lookups() { return lookups + (filled ? windowLookups() : 0); },
         get uniformMaterial() { return lastMaterial; },
         get tracksMaterial() { return ringOn; },
+        get cachesSites() { return sw > 0; },
         window(x0, y0, x1, y1) {
             if (filled)
                 lookups += windowLookups();
@@ -497,8 +525,21 @@ export function createDisplayViewExpectedSignal(input) {
             if (siteCache.length < sw * sh)
                 siteCache = new Float64Array(sw * sh);
             siteCache.fill(NaN, 0, sw * sh);
-            if (!input.kernels)
+            if (!input.kernels) {
+                // A ring of at least twice the window's rows keeps the rows of the previous display row's windows.
+                if (sh > 0 && directRows < 2 * sh) {
+                    let rows = 1;
+                    while (rows < 2 * sh)
+                        rows *= 2;
+                    if (rows * W <= CACHE_LIMIT) {
+                        directRows = rows;
+                        directRing = new Float64Array(rows * W).fill(NaN);
+                        directRowId = new Int32Array(rows).fill(-1);
+                    }
+                }
+                directOn = sh > 0 && directRows >= 2 * sh;
                 return;
+            }
             for (const group of groups) {
                 group.cx0 = x0 + group.minIx - R;
                 group.cy0 = y0 + group.minIy - R;
@@ -841,6 +882,8 @@ function correctionStates(key) {
  * AHD choice terms; 33 a 1 when the AHD correction applies and [34, 37) its values.
  */
 const MEMO_SIZE = 37;
+/** Most real pixels a display pixel's footprint may have for the per-real-pixel memo (#392); larger footprints rarely repeat a real pixel. */
+const PIXEL_MEMO_LIMIT = 1 << 16;
 /** Pilot points per axis: about one per two sites of the footprint plus its reach, 4 to 16. */
 function pilotCount(span) { return Math.max(4, Math.min(16, Math.ceil(span / 2))); }
 /** Renders the display view (docs/DISPLAY_VIEW.md). */
@@ -1063,6 +1106,13 @@ export async function renderDisplayView(setup) {
     let siteCount = 0, sampleCount = 0, detail = 0, uniform = 0, lastYield = Date.now();
     /** Recorded terms of samples whose sites all read one chart material, by material·4 + CFA phase (layout: MEMO_SIZE). */
     const sampleMemo = new Map();
+    // Per-real-pixel memo (#392): a sample's recorded terms depend only on its real pixel (its sites' expected electrons and its
+    // CFA phase), not on the display pixel or the sample, so a later sample of the same real pixel in the same display pixel
+    // replays them (the same values added to the same sums in the same order, as the one-material memo does). Slots cover the
+    // display pixel's footprint and are valid while their stamp equals the display pixel's generation. A replayed sample still
+    // counts its sites; it is used only where every site lies in the window's site cache, where reading it again would have
+    // cost no work and no scene lookup.
+    let pixelStamp = new Int32Array(0), pixelRecords = new Float64Array(0), pixelGeneration = 0;
     // Pilot: the scene at a deterministic grid over each display pixel's footprint widened by the reach; a pixel is uniform when
     // every point returns the same value. Pixels next to a detailed pixel count as detailed too, so an edge that only clips a
     // footprint's corner (too thin for the grid) still gets the full samples. The grid is fixed, so the sample count is not
@@ -1118,6 +1168,17 @@ export async function renderDisplayView(setup) {
                 detail++;
             setup.signal.window(Math.floor(vx * sx) + margin - windowReach, Math.floor(vy * sy) + margin - windowReach, Math.ceil((vx + 1) * sx) + margin + windowReach, Math.ceil((vy + 1) * sy) + margin + windowReach);
             const jitter = createDeterministicUniformStream(deriveNativeSiteStreamSeedUint32(seed, index, DISPLAY_VIEW_JITTER_STREAM_ID)), tracking = setup.signal.tracksMaterial;
+            const mx0 = Math.floor(vx * sx) + margin, my0 = Math.floor(vy * sy) + margin;
+            const mw = Math.min(frameWidth - 1, Math.ceil((vx + 1) * sx)) + margin - mx0 + 1, mh = Math.min(frameHeight - 1, Math.ceil((vy + 1) * sy)) + margin - my0 + 1;
+            const pixelMemo = setup.signal.cachesSites && mw * mh <= PIXEL_MEMO_LIMIT;
+            if (pixelMemo) {
+                if (pixelStamp.length < mw * mh) {
+                    pixelStamp = new Int32Array(mw * mh);
+                    pixelRecords = new Float64Array(mw * mh * MEMO_SIZE);
+                    pixelGeneration = 0;
+                }
+                pixelGeneration++;
+            }
             let s0 = 0, s1 = 0, s2 = 0, c00 = 0, c01 = 0, c02 = 0, c11 = 0, c12 = 0, c22 = 0, r0 = 0, r1 = 0, r2 = 0, pixelVariance = 0, corrected = false;
             for (let b = 0; b < K; b++)
                 for (let a = 0; a < K; a++) {
@@ -1125,53 +1186,69 @@ export async function renderDisplayView(setup) {
                     const x = Math.min(frameWidth - 1, Math.floor(fx)) + margin, y = Math.min(frameHeight - 1, Math.floor(fy)) + margin;
                     const phase = (y & 1) * 2 + (x & 1), list = phaseList[phase];
                     let material = -2;
+                    const px = x - mx0, py = y - my0;
+                    const pk = pixelMemo && px >= 0 && py >= 0 && px < mw && py < mh && x >= reach && y >= reach && x + reach < nativeWidth && y + reach < nativeHeight ? py * mw + px : -1;
+                    let memo, mo = 0;
+                    if (pk >= 0 && pixelStamp[pk] === pixelGeneration) {
+                        memo = pixelRecords;
+                        mo = pk * MEMO_SIZE;
+                        siteCount += list.length;
+                    }
                     // The expected electrons of the sites the demosaic reads (sites outside the raster, at mirror borders, are read
                     // reflect-101); where the signal tracks it, whether they all read one chart material, with the statistics below only
                     // when the sample is not replayed; otherwise the statistics at once.
-                    for (let li = 0; li < list.length; li++) {
-                        const slot = list[li];
-                        siteCount++;
-                        let sxs = x + (slot % side) - reach, sys = y + ((slot / side) | 0) - reach;
-                        if (sxs < 0)
-                            sxs = -sxs;
-                        else if (sxs >= nativeWidth)
-                            sxs = 2 * nativeWidth - 2 - sxs;
-                        if (sys < 0)
-                            sys = -sys;
-                        else if (sys >= nativeHeight)
-                            sys = 2 * nativeHeight - 2 - sys;
-                        const c = (sys & 1) === 0 ? ((sxs & 1) === 0 ? 0 : 1) : ((sxs & 1) === 0 ? 1 : 2);
-                        const e = setup.signal.site(sxs, sys) + dark[c];
-                        siteChannel[slot] = c;
-                        if (tracking) {
-                            siteElectrons[slot] = e;
-                            const own = setup.signal.uniformMaterial;
-                            material = material === -2 || material === own ? own : -1;
-                            continue;
-                        }
-                        // As siteStatistics, written out here for the untracked (Speed) path.
-                        const kc = k[c], mean = kc * e, variance = kc * kc * e + c0[c], gap = 1 - mean;
-                        siteThird[slot] = kc * kc * kc * e;
-                        if (gap > 0 && gap * gap > reach2 * variance) {
-                            siteMean[slot] = mean;
-                            siteVar[slot] = variance;
-                        }
-                        else {
-                            upperClip(mean, variance, 1, clip);
-                            siteMean[slot] = clip[0];
-                            siteVar[slot] = clip[1];
+                    if (!memo)
+                        for (let li = 0; li < list.length; li++) {
+                            const slot = list[li];
+                            siteCount++;
+                            let sxs = x + (slot % side) - reach, sys = y + ((slot / side) | 0) - reach;
+                            if (sxs < 0)
+                                sxs = -sxs;
+                            else if (sxs >= nativeWidth)
+                                sxs = 2 * nativeWidth - 2 - sxs;
+                            if (sys < 0)
+                                sys = -sys;
+                            else if (sys >= nativeHeight)
+                                sys = 2 * nativeHeight - 2 - sys;
+                            const c = (sys & 1) === 0 ? ((sxs & 1) === 0 ? 0 : 1) : ((sxs & 1) === 0 ? 1 : 2);
+                            const e = setup.signal.site(sxs, sys) + dark[c];
+                            siteChannel[slot] = c;
+                            if (tracking) {
+                                siteElectrons[slot] = e;
+                                const own = setup.signal.uniformMaterial;
+                                material = material === -2 || material === own ? own : -1;
+                                continue;
+                            }
+                            // As siteStatistics, written out here for the untracked (Speed) path.
+                            const kc = k[c], mean = kc * e, variance = kc * kc * e + c0[c], gap = 1 - mean;
+                            siteThird[slot] = kc * kc * kc * e;
+                            if (gap > 0 && gap * gap > reach2 * variance) {
+                                siteMean[slot] = mean;
+                                siteVar[slot] = variance;
+                            }
+                            else {
+                                upperClip(mean, variance, 1, clip);
+                                siteMean[slot] = clip[0];
+                                siteVar[slot] = clip[1];
+                            }
                         }
-                    }
                     if (!tracking)
                         material = -1;
                     // A sample whose sites all read one chart material only has the statistics of every other such sample of that material
                     // and CFA phase: replay its recorded terms (the same values added to the same sums in the same order).
-                    const memoKey = material >= 0 ? material * 4 + phase : -1, memo = memoKey >= 0 ? sampleMemo.get(memoKey) : undefined;
+                    const memoKey = !memo && material >= 0 ? material * 4 + phase : -1;
+                    if (memoKey >= 0) {
+                        memo = sampleMemo.get(memoKey);
+                        if (memo && pk >= 0) {
+                            pixelRecords.set(memo, pk * MEMO_SIZE);
+                            pixelStamp[pk] = pixelGeneration;
+                        }
+                    }
                     const cs = candidateSlots[phase], cw = candidateWeights[phase], count = cs.length, share = 1 / count;
                     if (memo) {
                         for (let d = 0; d < count; d++) {
                             for (let c = 0; c < 3; c++) {
-                                const o = 3 + (d * 3 + c) * 3, a0 = memo[o], a1 = memo[o + 1], a2 = memo[o + 2], wgt = share * B[c] * memo[c];
+                                const o = mo + 3 + (d * 3 + c) * 3, a0 = memo[o], a1 = memo[o + 1], a2 = memo[o + 2], wgt = share * B[c] * memo[mo + c];
                                 c00 += wgt * a0 * a0;
                                 c01 += wgt * a0 * a1;
                                 c02 += wgt * a0 * a2;
@@ -1179,27 +1256,27 @@ export async function renderDisplayView(setup) {
                                 c12 += wgt * a1 * a2;
                                 c22 += wgt * a2 * a2;
                             }
-                            r0 += memo[21 + d * 3];
-                            r1 += memo[22 + d * 3];
-                            r2 += memo[23 + d * 3];
+                            r0 += memo[mo + 21 + d * 3];
+                            r1 += memo[mo + 22 + d * 3];
+                            r2 += memo[mo + 23 + d * 3];
                         }
-                        s0 += memo[27];
-                        s1 += memo[28];
-                        s2 += memo[29];
+                        s0 += memo[mo + 27];
+                        s1 += memo[mo + 28];
+                        s2 += memo[mo + 29];
                         if (count === 2) {
-                            r0 += memo[30];
-                            r1 += memo[31];
-                            r2 += memo[32];
+                            r0 += memo[mo + 30];
+                            r1 += memo[mo + 31];
+                            r2 += memo[mo + 32];
                         }
-                        if (memo[33] === 1) {
-                            s0 += memo[34];
-                            s1 += memo[35];
-                            s2 += memo[36];
+                        if (memo[mo + 33] === 1) {
+                            s0 += memo[mo + 34];
+                            s1 += memo[mo + 35];
+                            s2 += memo[mo + 36];
                             corrected = true;
                         }
                         continue;
                     }
-                    const record = memoKey >= 0 ? new Float64Array(MEMO_SIZE) : undefined;
+                    const record = memoKey >= 0 ? new Float64Array(MEMO_SIZE) : pk >= 0 ? pixelRecords.subarray(pk * MEMO_SIZE, (pk + 1) * MEMO_SIZE).fill(0) : undefined;
                     if (tracking)
                         for (let li = 0; li < list.length; li++) {
                             const slot = list[li];
@@ -1391,8 +1468,13 @@ export async function renderDisplayView(setup) {
                             record[36] = fix[2];
                         }
                     }
-                    if (record)
+                    if (record && memoKey >= 0) {
                         sampleMemo.set(memoKey, record);
+                        if (pk >= 0)
+                            pixelRecords.set(record, pk * MEMO_SIZE);
+                    }
+                    if (pk >= 0)
+                        pixelStamp[pk] = pixelGeneration;
                     pixelVariance = 0;
                 }
             sampleCount += Q;