@meimu/mutracer 0.2.0 → 0.3.1

package/lib/renderer/WGPURenderingPipeline.js

@@ -1,9 +1,8 @@
-import { hdrResolveWGSL } from './wgsl/compose.frag.wgsl.js';
+import { hdrResolveWGSL, TONE_MAPPING_MODES } from './wgsl/compose.frag.wgsl.js';
 import { oidnAuxiliaryDefine } from './wgsl/oidnAuxiliary.wgsl.js';
 import { displayAovKind, DEFAULT_AOV_DISPLAY } from './aovDisplay.js';
 import { WGPUAov } from './WGPUAov.js';
-import { aovMask } from './aov.js';
-import { scheduleFrame } from '../util/frame.js';
+import { aovMask, COMPACT_AOV_KINDS, DISPLAY_AOV_SAMPLE_CAP } from './aov.js';
 import { DisplayPostProcess } from './DisplayPostProcess.js';
 import { customDenoiseLayersMain, customDenoiseCoverageMain } from './wgsl/customDenoise.wgsl.js';
 import { WGPUCanvasSurface } from './WGPUCanvasSurface.js';
@@ -18,6 +17,7 @@ import WGPURayTracePass from './WGPURayTracePass.js';
 import { composeMain, composeDefine, compositeDenoiseOutputMain, compositeDenoiseDisplayMain, linearToSrgbDefine } from './wgsl/compose.frag.wgsl.js';
 import halton from './halton.js';
 import { makeTileRender, makeTileRenderWithPredict } from './TileRender.js';
+import { WORKGROUP_SIZE } from './wgsl/rayTrace.compute.js';
 import { WGPURayTraceOutputPass } from './WGPURayTraceOutput.js';
 import { vec3 } from '../math.js';
 import WGPUBloomPass from './WGPUBloomPass.js';
@@ -28,16 +28,16 @@ export const oidnAlbedoSrgbEncodeMain = /* wgsl */ `
 if (globalId.x >= u32(imageSize.x) || globalId.y >= u32(imageSize.y)) { return; }
 let index = globalId.x + globalId.y * u32(imageSize.x);
 let raw = textureLoad(in_albedo, vec2u(globalId.xy), 0);
-let encoded = sT(raw.rgb);
+let encoded = uq(raw.rgb);
 out_albedo[index] = vec4f(encoded, raw.a);
 `;
 export const oidnAlbedoSrgbDecodeMain = /* wgsl */ `
 if (globalId.x >= u32(imageSize.x) || globalId.y >= u32(imageSize.y)) { return; }
 let index = globalId.x + globalId.y * u32(imageSize.x);
 let filtered = in_albedo[index];
-let linear = sS(filtered.rgb);
+let linear = uo(filtered.rgb);
 var result = linear;
-let jD = textureLoad(in_rawAlbedo, vec2i(globalId.xy), 0).a;
+let jN = textureLoad(in_rawAlbedo, vec2i(globalId.xy), 0).a;
 if (preserveSurfaceTexture != 0u) {
 
 
@@ -45,33 +45,33 @@ if (preserveSurfaceTexture != 0u) {
 let pixel = vec2i(globalId.xy);
 let center = textureLoad(in_rawNormal, pixel, 0);
 let n = normalize(center.rgb * 2.0 - 1.0 + vec3f(1e-8));
-var oc = 0.0;
+var oR = 0.0;
 for (var y = -1; y <= 1; y++) {
 for (var x = -1; x <= 1; x++) {
-let vw = textureLoad(in_rawNormal,
+let xA = textureLoad(in_rawNormal,
 clamp(pixel + vec2i(x, y), vec2i(0), imageSize - 1), 0);
-let nn = normalize(vw.rgb * 2.0 - 1.0 + vec3f(1e-8));
-oc = max(oc,
-max(1.0 - dot(n, nn), abs(center.a - vw.a)));
+let nn = normalize(xA.rgb * 2.0 - 1.0 + vec3f(1e-8));
+oR = max(oR,
+max(1.0 - dot(n, nn), abs(center.a - xA.a)));
 }
 }
-let vO = smoothstep(0.02, 0.1, oc);
+let xY = smoothstep(0.02, 0.1, oR);
 let raw = clamp(textureLoad(in_rawAlbedo, pixel, 0).rgb,
 vec3f(0.0), vec3f(1.0));
-result = mix(raw, linear, vO);
+result = mix(raw, linear, xY);
 }
-out_albedo[index] = vec4f(result, jD);
+out_albedo[index] = vec4f(result, jN);
 `;
 export const oidnNormalSanitizeMain = /* wgsl */ `
 if (globalId.x >= u32(imageSize.x) || globalId.y >= u32(imageSize.y)) { return; }
 let index = globalId.x + globalId.y * u32(imageSize.x);
-out_normal[index] = vec4f(rL(in_normal[index].rgb), 1.0);
+out_normal[index] = vec4f(sW(in_normal[index].rgb), 1.0);
 `;
 function createTimeQuery(device) {
     try {
         const querySet = device.createQuerySet({
             type: 'timestamp',
-            count: 2
+            count: 16
         });
         const resolveBuffer = device.createBuffer({
             size: querySet.count * 8,
@@ -100,6 +100,9 @@ function makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scrat
     // the next presentation or read resolves them once.
     let realtimeDeferPostProcess = false;
     let postProcessPending = false;
+    // Resolve uses the configuration that produced these buffers, even if another
+    // target has since changed the shared trace pass's caustic settings.
+    let sampledOutput;
     let offlineSamplesPerBatch = 0;
     let deferPostProcess = false;
     let sampleSequenceOffset = 0;
@@ -109,6 +112,7 @@ function makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scrat
     let elapsedFrameTime = 32;
     let elapsedTileTime;
     let tileTimingGeneration = 0;
+    let causticBatchTimeMs = 0, photonBatchTimeMs = 0;
     let lastGpuTraceTiming;
     let displayTrace;
     let diagnosticsReadbackPromise = Promise.resolve();
@@ -228,13 +232,15 @@ function makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scrat
         }).query
         : undefined;
     const tileRender = makeTileRender();
-    const tileRenderWithPredict = timeQuery ? makeTileRenderWithPredict() : undefined;
+    const tileRenderWithPredict = timeQuery ? makeTileRenderWithPredict(WORKGROUP_SIZE) : undefined;
     tileRender.setDesiredMsPerTile(maxTimePerTile);
     tileRenderWithPredict?.setDesiredMsPerTile(maxTimePerTile);
     function invalidateTilePrediction() {
         tileTimingGeneration++;
         tileRenderWithPredict?.needsUpdatePredicting();
         lastGpuTraceTiming = undefined;
+        causticBatchTimeMs = 0;
+        photonBatchTimeMs = 0;
         // A changed render configuration needs fresh timing. Refresh
         // its estimator without submitting a hidden probe in that mode.
         needsUpdatePredicting = offlineSamplesPerBatch === 0;
@@ -261,9 +267,9 @@ function makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scrat
 var color = load_colorTex(uv, 0);
 let coverage = clamp(load_coverageTex(uv, 0).a, 0.0, 1.0);
 color = vec4f(
-jQ(color.r, coverage, flatBackgroundColor.a > 0.5, true),
-jQ(color.g, coverage, flatBackgroundColor.a > 0.5, true),
-jQ(color.b, coverage, flatBackgroundColor.a > 0.5, true), color.a);
+ka(color.r, coverage, flatBackgroundColor.a > 0.5, true),
+ka(color.g, coverage, flatBackgroundColor.a > 0.5, true),
+ka(color.b, coverage, flatBackgroundColor.a > 0.5, true), color.a);
 output.color = color;
 `
     }));
@@ -387,11 +393,11 @@ output.color = color;
     oidnNormalSanitizePass.setOutputParams({ normal: { channels: 4 } });
     const outputPass = scratch.get('outputPass', () => new WGPUFullQuadPass('output', device, {
         fsMain: /* wgsl */ `
-let xs = min(
+let zU = min(
 vec2i(uv2 * vec2f(colorTexRegion())),
 vec2i(colorTexRegion()) - vec2i(1)
 );
-var color = load_colorTex(xs, 0);
+var color = load_colorTex(zU, 0);
 color = vec4(color.rgb * color.a, color.a);
 output.color = color;
 `,
@@ -424,7 +430,8 @@ output.color = color;
         _updateSeed(renderWidth, renderHeight);
         const activeTimeQuery = timeQuery;
         const isUnmapped = activeTimeQuery?.resultBuffer.mapState === 'unmapped';
-        rayTracePass.createPass(encoder, clear, tiles, activeTimeQuery ? { querySet: activeTimeQuery.querySet } : undefined);
+        const measuredCausticBatch = rayTracePass.createPass(encoder, clear, tiles, activeTimeQuery ? { querySet: activeTimeQuery.querySet } : undefined);
+        sampledOutput = rayTracePass.getOutputBuffer();
         if (activeTimeQuery) {
             encoder.resolveQuerySet(activeTimeQuery.querySet, 0, activeTimeQuery.querySet.count, activeTimeQuery.resolveBuffer, 0);
             if (isUnmapped) {
@@ -440,20 +447,31 @@ output.color = color;
             diagnosticsReadbackPromise = activeTimeQuery.resultBuffer
                 .mapAsync(GPUMapMode.READ).then(() => {
                 const mappedRange = activeTimeQuery.resultBuffer.getMappedRange();
-                const times = new BigInt64Array(mappedRange, 0, 2);
-                const traceTime = Math.max(Number(times[1] - times[0]) / 1_000_000, 0.1);
+                const times = new BigInt64Array(mappedRange, 0, 16);
+                const causticTime = (measuredCausticBatch & 1) ? Math.max(Number(times[3] - times[2] + times[5] - times[4]) / 1_000_000, 0) : 0;
+                // Independent timestamp pairs avoid Metal's cross-pass counter bug.
+                const photonTime = (measuredCausticBatch & 2) ? Math.max(Number(times[7] - times[6] + times[9] - times[8] + times[11] - times[10] + times[13] - times[12] + times[15] - times[14]) / 1_000_000, 0) : 0;
+                const ptTime = Math.max(Number(times[1] - times[0]) / 1_000_000, 0);
                 // A readback may finish after scene preparation or a mode switch.
                 // It must not overwrite throughput learned for the current scene.
                 const timingIsCurrent = !disposed && submittedTimingGeneration === tileTimingGeneration &&
                     !isFirstFrame;
                 if (timingIsCurrent) {
+                    if (measuredCausticBatch & 1)
+                        causticBatchTimeMs = causticTime;
+                    if (measuredCausticBatch & 2)
+                        photonBatchTimeMs = photonTime;
+                    const traceTime = Math.max(ptTime + (causticBatchTimeMs + photonBatchTimeMs) / submittedTileCount, .1);
                     lastGpuTraceTiming = {
+                        causticTimeMs: causticBatchTimeMs, photonMappingTimeMs: photonBatchTimeMs,
+                        photonStagesMs: (measuredCausticBatch & 2) ? [6, 8, 10, 12, 14].map(i => Math.max(Number(times[i + 1] - times[i]) / 1_000_000, 0)) : undefined,
+                        pathTracingTimeMs: ptTime,
                         tileTimeMs: traceTime,
                         tileTimePerSampleMs: traceTime,
                         estimatedFullFrameTimeMs: traceTime * submittedTileCount,
                         tileCount: submittedTileCount
                     };
-                    submittedTileRenderWithPredict.setLastTraceTime(traceTime);
+                    submittedTileRenderWithPredict.setLastTraceTime(traceTime, tiles[0], tiles[1]);
                 }
                 activeTimeQuery.resultBuffer.unmap();
             }).catch(() => {
@@ -556,7 +574,7 @@ output.color = color;
             denoisedTexture = prepareDenoisedTexture(encoder, denoisedBuffer, denoisedTexture);
         if (resolve) {
             rayTraceOutputPass.setSampleCount(sampleCount);
-            rayTraceOutputPass.createPass(encoder, rayTracePass.getOutputBuffer(), resolvedHasShadowCatcher);
+            rayTraceOutputPass.createPass(encoder, sampledOutput ?? rayTracePass.getOutputBuffer(), resolvedHasShadowCatcher);
         }
         composePass.setUniform('shadowCatcherEnabled', +resolvedHasShadowCatcher);
         let foregroundTexture = getFrameInput(resolvedHasShadowCatcher ? 'foreground' : 'color');
@@ -629,10 +647,12 @@ output.color = color;
         finishPresentation(encoder, displayTexture);
     }
     function finishPresentation(encoder, displayTexture) {
+        const presentationWidth = displayAovKind(output) ? displayTexture.width : renderWidth;
+        const presentationHeight = displayAovKind(output) ? displayTexture.height : renderHeight;
         const activeHDRPeakMeter = hdrOutputActive
             ? (hdrPeakMeter ??= scratch.get('hdrPeak', () => new WGPUHDRPeakMeter(device)))
             : undefined;
-        const hdrPeakReadbackSubmitted = activeHDRPeakMeter?.encode(encoder, displayTexture, renderWidth, renderHeight) ?? false;
+        const hdrPeakReadbackSubmitted = activeHDRPeakMeter?.encode(encoder, displayTexture, presentationWidth, presentationHeight) ?? false;
         if (output === 'normal' || output === 'albedo') {
             displayTrace?.push('AOV:Raw');
             displayTexture = getFrameInput(output);
@@ -641,14 +661,14 @@ output.color = color;
             displayTrace?.push('AOV:Raw');
             displayTexture = getFrameInput('shadowCatcher');
         }
-        if (displayTexture.width < renderWidth || displayTexture.height < renderHeight) {
-            readbackPass.setSize(renderWidth, renderHeight);
+        if (displayTexture.width < presentationWidth || displayTexture.height < presentationHeight) {
+            readbackPass.setSize(presentationWidth, presentationHeight);
             readbackPass.createPass(encoder, { inputTex: displayTexture });
             displayTexture = readbackPass.getOutput('color');
         }
         // Keep the completed denoise visible until its replacement is ready.
         if (!(preserveDenoisedOutput && output === 'final' && !denoiseValid && presentationDenoised)) {
-            const width = renderWidth, height = renderHeight;
+            const width = presentationWidth, height = presentationHeight;
             if (!presentationTexture || presentationTexture.width !== width || presentationTexture.height !== height || presentationTexture.format !== displayTexture.format) {
                 const previous = presentationTexture;
                 presentationTexture = device.createTexture({
@@ -673,20 +693,28 @@ output.color = color;
         postProcessPending = false;
         drawPostProcess(device.createCommandEncoder(), false, true);
     }
+    const aovResolution = () => execution?.aovResolution === 'display' ? { width: canvas.width, height: canvas.height } : undefined;
+    const compactAov = () => !!aovResolution() && !!execution?.aovs?.every(kind => COMPACT_AOV_KINDS.includes(kind));
     function trace(camera, maxSamples) {
+        applyTraceQuality();
         // A call to draw means accumulation has been invalidated. Cancel OIDN
         // before checking shader compilation: pipeline-affecting parameter changes
         // otherwise leave the previous asynchronous denoise alive while resources
         // and bind groups are being replaced.
         cancelDenoise();
-        if (rayTracePass.isCompilingShader()) {
-            isFirstFrame = true;
-            sampleCount = 0;
-            return true;
-        }
         // Update the camera before compiling and sampling.
         rayTracePass.setCamera(camera);
         aovCamera = camera;
+        rayTracePass.updatePipeline();
+        const pipelineError = rayTracePass.getPipelineError();
+        if (pipelineError)
+            throw pipelineError;
+        // Waiting for a shader is not an input change: this render's samples and
+        // complete image stay valid, and only Render's restart discards them.
+        if (rayTracePass.isCompilingShader() || !rayTracePass.isPipelineReady())
+            return true;
+        if (execution?.aovs?.length && !rayTracePass.prepareAovs(execution.aovs, compactAov()))
+            return true;
         const resetAccumulation = isFirstFrame;
         if (resetAccumulation)
             aov.reset();
@@ -696,20 +724,11 @@ output.color = color;
             denoiseValid = false;
             tileTimingGeneration++;
             elapsedTileTime = undefined;
-            rayTracePass.setCamera(camera);
             (tileRenderWithPredict || tileRender).reset();
             // Reset
             isFirstFrame = false;
             sampleCount = 0;
         }
-        rayTracePass.updatePipeline();
-        if (rayTracePass.isCompilingShader() || !rayTracePass.isPipelineReady()) {
-            isFirstFrame = true;
-            sampleCount = 0;
-            return true;
-        }
-        if (execution?.aovs?.length && !rayTracePass.prepareAovs(execution.aovs))
-            return true;
         // Keep the last completed denoise visible while a static while-converging batch
         // accumulates, including the incomplete first sample after a scene edit.
         if (!preserveDenoisedOutput || isFirstFrame) {
@@ -802,7 +821,13 @@ output.color = color;
             return false;
         }
         if (sampleCount !== frameSampleCount && execution?.aovs?.length) {
-            rayTracePass.renderAovs(aov, camera, sampleCount, execution.aovSamples ?? 16, execution.aovs);
+            // Display AOVs only add detail: keep the first beauty image's latency and
+            // spread their full-canvas samples over frames instead of batching them.
+            // The converging trace completes any remaining samples.
+            const display = aovResolution();
+            const aovTarget = display && sampleCount < maxSamples ? Math.min(sampleCount - 1, aov.samples + 1) : sampleCount;
+            if (aovTarget > 0)
+                rayTracePass.renderAovs(aov, camera, aovTarget, Math.min(execution.aovSamples ?? 16, display ? DISPLAY_AOV_SAMPLE_CAP : Infinity), execution.aovs, display);
         }
         if (sampleCount !== frameSampleCount && realtime && realtimeDeferPostProcess && sampleCount < renderSampleTarget) {
             postProcessPending = true;
@@ -840,6 +865,7 @@ output.color = color;
         // The target retains its complete presentation texture through the resize.
         clearDenoisedOutput();
         tileTimingGeneration++;
+        sampledOutput = undefined;
         renderWidth = nextRenderWidth;
         renderHeight = nextRenderHeight;
         (tileRenderWithPredict || tileRender).setSize(renderWidth, renderHeight);
@@ -877,13 +903,7 @@ output.color = color;
     }
     function setToneMappingParams(params) {
         const newExposure = params.exposure ?? 1;
-        const newToneMappingMode = {
-            agx: 0,
-            aces: 1,
-            cineon: 2,
-            reinhard: 3,
-            linear: 4
-        }[params.toneMapping ?? 'agx'] ?? 0;
+        const newToneMappingMode = TONE_MAPPING_MODES[params.toneMapping ?? 'agx'] ?? 0;
         const newContrast = params.contrast ?? 1;
         const newSaturation = params.saturation ?? 1;
         const newTemperature = params.temperature ?? 0;
@@ -1289,31 +1309,37 @@ output.color = color;
             rayTraceOutputPass.dispose();
         });
     }
+    // Keep tracing quality out of presentation: an old fallback must not
+    // invalidate a new caustic pipeline while it is compiling.
+    function applyTraceQuality() {
+        if (execution) {
+            rayTracePass.setQuality(execution);
+            rayTracePass.setBevelSamples(execution.bevelSamples);
+            rayTracePass.setAlphaBlendStrategy(execution.alphaBlendStrategy);
+            rayTracePass.setSamplingPattern(execution.samplingPattern, execution.maxSamples);
+        }
+    }
     function activate() {
         rayTracePass.useTarget(targetKey);
         if (renderWidth && renderHeight)
             rayTracePass.setSize(renderWidth, renderHeight, screenWidth / screenHeight);
         if (execution) {
-            rayTracePass.setQuality(execution);
             rayTracePass.setClamping(execution.clamping);
             rayTracePass.setTransmissiveOutputAlphaMin(execution.transmissiveOutputAlphaMin);
-            rayTracePass.setBevelSamples(execution.bevelSamples);
-            rayTracePass.setAlphaBlendStrategy(execution.alphaBlendStrategy);
-            rayTracePass.setSamplingPattern(execution.samplingPattern, execution.maxSamples);
         }
     }
     return {
         invalidateTiming: invalidateTilePrediction,
         invalidateDenoisedOutput() { cancelDenoise(); denoiseValid = false; preserveDenoisedOutput = false; },
         configure(settings) {
-            const timingKeys = ['bounces', 'bevel', 'bevelSamples', 'directLightCandidates', 'dispersionWavelengths', 'alphaBlendStrategy', 'samplingPattern', 'clamping', 'transmissiveOutputAlphaMin'];
+            const timingKeys = ['bounces', 'bevel', 'bevelSamples', 'directLightCandidates', 'dispersionWavelengths', 'alphaBlendStrategy', 'samplingPattern', 'clamping', 'transmissiveOutputAlphaMin', 'caustics'];
             if (!execution || timingKeys.some(key => execution[key] !== settings[key]))
                 invalidateTilePrediction();
             if (settings.aovs?.length && (!Number.isInteger(settings.aovSamples ?? 16) || (settings.aovSamples ?? 16) < 1))
                 throw new RangeError('aovSamples must be a positive integer');
             const previousMask = aovMask(execution?.aovs ?? []), nextMask = aovMask(settings.aovs ?? []);
-            if (previousMask !== nextMask || execution?.aovSamples !== settings.aovSamples)
-                aov.samples = 0;
+            if (previousMask !== nextMask || execution?.aovSamples !== settings.aovSamples || execution?.aovResolution !== settings.aovResolution)
+                aov.reset();
             execution = { ...settings, aovs: [...(settings.aovs ?? [])] };
             // Presentation may still name the previous preview's AOV. Drop that
             // selection before tracing with a smaller set; Display validates and
@@ -1341,7 +1367,8 @@ output.color = color;
         },
         setRealtimeBatchBudget(milliseconds) { realtimeBatchBudgetMs = milliseconds; },
         setRealtimeDeferPostProcess(defer) { realtimeDeferPostProcess = defer; },
-        getRealtimeSampleTime() { return lastGpuTraceTiming?.tileCount === 1 ? lastGpuTraceTiming.estimatedFullFrameTimeMs : undefined; },
+        getRealtimeSampleTime() { return lastGpuTraceTiming?.estimatedFullFrameTimeMs; },
+        getRealtimeTileTime() { return lastGpuTraceTiming?.tileTimePerSampleMs; },
         whenTraceAvailable() { return traceQueue.whenAvailable(); },
         get presentationComplete() { return !!presentationTexture; },
         get presentationDenoised() { return presentationDenoised; },
@@ -1380,15 +1407,16 @@ output.color = color;
             isFirstFrame = true;
             sampleCount = 0;
         },
+        getAovTexture(kind) { return execution?.aovs?.includes(kind) ? aov.texture(kind) : undefined; },
         getOutputTexture(kind) {
             flushPostProcess();
             if (kind === 'hdr')
                 return resolvedSamples > 0 ? getFrameInput('color') : undefined;
             return displayPostProcess.output ?? presentationTexture;
         },
-        applyPostProcesses(passes, render) {
+        applyPostProcesses(passes, render, options, crop) {
             if (presentationTexture)
-                displayPostProcess.run(presentationTexture, passes, render);
+                displayPostProcess.run(presentationTexture, passes, render, canvas, options, crop);
         },
         trace,
         drawPostProcess() {
@@ -1434,21 +1462,35 @@ output.color = color;
         refineAovs(camera, samples = sampleCount) {
             if (samples < 1 || !execution?.aovs?.length)
                 return true;
+            applyTraceQuality();
             rayTracePass.setCamera(camera);
             aovCamera = camera;
             rayTracePass.updatePipeline();
+            const pipelineError = rayTracePass.getPipelineError();
+            if (pipelineError)
+                throw pipelineError;
             if (rayTracePass.isCompilingShader() || !rayTracePass.isPipelineReady())
                 return false;
-            return rayTracePass.renderAovs(aov, camera, samples, execution.aovSamples ?? 16, execution.aovs);
+            return rayTracePass.renderAovs(aov, camera, samples, Math.min(execution.aovSamples ?? 16, aovResolution() ? DISPLAY_AOV_SAMPLE_CAP : Infinity), execution.aovs, aovResolution());
         },
         async readAov(kind) {
             if (!execution?.aovs?.includes(kind) || !aovCamera || (sampleCount < 1 && aov.samples < 1))
                 throw new Error('AOV output is not ready');
-            rayTracePass.setCamera(aovCamera);
-            while (!rayTracePass.renderAovs(aov, aovCamera, Math.max(sampleCount, aov.samples), execution.aovSamples ?? 16, execution.aovs)) {
+            for (;;) {
                 if (disposed)
                     throw new Error('AOV compilation was interrupted');
-                await new Promise(resolve => scheduleFrame(() => resolve()));
+                activate();
+                applyTraceQuality();
+                rayTracePass.setCamera(aovCamera);
+                rayTracePass.updatePipeline();
+                const pipelineError = rayTracePass.getPipelineError();
+                if (pipelineError)
+                    throw pipelineError;
+                if (!rayTracePass.isCompilingShader() && rayTracePass.isPipelineReady() &&
+                    rayTracePass.renderAovs(aov, aovCamera, Math.max(sampleCount, aov.samples), Math.min(execution.aovSamples ?? 16, aovResolution() ? DISPLAY_AOV_SAMPLE_CAP : Infinity), execution.aovs, aovResolution()))
+                    break;
+                // Display frames stop on a hidden page, but compilation still completes.
+                await new Promise(resolve => setTimeout(resolve, 16));
             }
             return aov.read(kind);
         },
@@ -1532,7 +1574,7 @@ output.color = color;
                     setSize(input.width, input.height);
                     rayTracePass.useTarget(targetKey);
                     rayTracePass.setSize(renderWidth, renderHeight, screenWidth / screenHeight);
-                    const buffers = rayTracePass.getOutputBuffer();
+                    const buffers = sampledOutput = rayTracePass.getOutputBuffer();
                     const shadow = new Float32Array(input.width * input.height * 12);
                     for (let i = 0; i < input.width * input.height; i++) {
                         shadow.set(input.shadow.subarray(i * 8, i * 8 + 8), i * 12);