@meimu/mutracer 0.1.5 → 0.3.0

package/lib/renderer/WGPURenderingPipeline.js

@@ -1,9 +1,15 @@
+import { hdrResolveWGSL } 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 { DisplayPostProcess } from './DisplayPostProcess.js';
 import { customDenoiseLayersMain, customDenoiseCoverageMain } from './wgsl/customDenoise.wgsl.js';
 import { WGPUCanvasSurface } from './WGPUCanvasSurface.js';
 import { WGPUScratchBuffer } from './WGPUScratchBuffer.js';
 import { WGPUScratchTexture } from './WGPUScratchTexture.js';
 import { ScratchPool } from './ScratchPool.js';
+import { GPUTraceQueue } from './GPUTraceQueue.js';
 import { makeRenderPipeline } from './renderPipeline.js';
 import { textureBytes } from './gpuMemory.js';
 import { WGPUFullQuadPass } from './WGPUFullQuadPass.js';
@@ -21,60 +27,50 @@ 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 linear = clamp(raw.rgb, vec3f(0.0), vec3f(1.0));
-let encoded = select(
-1.055 * pow(linear, vec3f(1.0 / 2.4)) - 0.055,
-12.92 * linear,
-linear <= vec3f(0.0031308)
-);
+let encoded = sQ(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 encoded = clamp(filtered.rgb, vec3f(0.0), vec3f(1.0));
-let linear = select(
-pow((encoded + 0.055) / 1.055, vec3f(2.4)),
-encoded / 12.92,
-encoded <= vec3f(0.04045)
-);
+let linear = sP(filtered.rgb);
 var result = linear;
-let jg = textureLoad(in_rawAlbedo, vec2i(globalId.xy), 0).a;
+let jj = textureLoad(in_rawAlbedo, vec2i(globalId.xy), 0).a;
 if (preserveSurfaceTexture != 0u) {
 
 
 
-let fQ = vec2i(globalId.xy);
-let center = textureLoad(in_rawNormal, fQ, 0);
+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 nf = 0.0;
+var nS = 0.0;
 for (var y = -1; y <= 1; y++) {
 for (var x = -1; x <= 1; x++) {
-let tV = textureLoad(in_rawNormal,
-clamp(fQ + vec2i(x, y), vec2i(0), imageSize - 1), 0);
-let nn = normalize(tV.rgb * 2.0 - 1.0 + vec3f(1e-8));
-nf = max(nf,
-max(1.0 - dot(n, nn), abs(center.a - tV.a)));
+let vI = textureLoad(in_rawNormal,
+clamp(pixel + vec2i(x, y), vec2i(0), imageSize - 1), 0);
+let nn = normalize(vI.rgb * 2.0 - 1.0 + vec3f(1e-8));
+nS = max(nS,
+max(1.0 - dot(n, nn), abs(center.a - vI.a)));
 }
 }
-let un = smoothstep(0.02, 0.1, nf);
-let raw = clamp(textureLoad(in_rawAlbedo, fQ, 0).rgb,
+let wc = smoothstep(0.02, 0.1, nS);
+let raw = clamp(textureLoad(in_rawAlbedo, pixel, 0).rgb,
 vec3f(0.0), vec3f(1.0));
-result = mix(raw, linear, un);
+result = mix(raw, linear, wc);
 }
-out_albedo[index] = vec4f(result, jg);
+out_albedo[index] = vec4f(result, jj);
 `;
 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(clamp(in_normal[index].rgb, vec3f(0.0), vec3f(1.0)), 1.0);
+out_normal[index] = vec4f(rG(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,
@@ -95,17 +91,29 @@ function createTimeQuery(device) {
         return undefined;
     }
 }
-function makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scratch, customJobs) {
+function makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scratch, customJobs, traceQueue) {
     let sampleRenderedCallback = () => { };
-    let allowMultipleSamplesPerFrame = false;
+    let batchSamples = false;
+    let realtimeBatchBudgetMs = Infinity;
+    // Samples traced between display frames skip the resolve and composition;
+    // 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;
+    const aov = new WGPUAov(device);
+    let aovCamera;
     let sampleCount = 0;
     let elapsedFrameTime = 32;
     let elapsedTileTime;
     let tileTimingGeneration = 0;
+    let causticBatchTimeMs = 0, photonBatchTimeMs = 0;
     let lastGpuTraceTiming;
+    let displayTrace;
     let diagnosticsReadbackPromise = Promise.resolve();
     let isFirstFrame = true;
     let disposed = false;
@@ -127,6 +135,8 @@ function makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scrat
     let denoiseValid = false;
     let maxTimePerTile = 21;
     let bloomIntensity = 0;
+    // Sample count of this accumulation's last bloom refresh.
+    let bloomSamples = 0;
     let bloomThreshold = 1;
     let bloomRadius = 0.6;
     let exposure = 1;
@@ -139,6 +149,7 @@ function makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scrat
     let hdrOutputRequested = false;
     let hdrOutputActive = false;
     let output = 'final';
+    let aovDisplayOptions = DEFAULT_AOV_DISPLAY;
     let shadowCatcherColor = vec3.create();
     let shadowCatcherAlpha = 1;
     let pageLeaveTime = performance.now();
@@ -227,6 +238,8 @@ function makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scrat
         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;
@@ -248,12 +261,14 @@ function makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scrat
         inputs: ['colorTex', 'coverageTex'],
         outputs: ['color'],
         uniforms: [{ label: 'flatBackgroundColor', type: 'vec4f', data: [0, 0, 0, 0] }],
+        fsDefine: hdrResolveWGSL,
         fsMain: /* wgsl */ `
 var color = load_colorTex(uv, 0);
 let coverage = clamp(load_coverageTex(uv, 0).a, 0.0, 1.0);
-if (flatBackgroundColor.a > 0.5 && coverage > 0.0) {
-color = vec4f(color.rgb * coverage, color.a);
-}
+color = vec4f(
+jx(color.r, coverage, flatBackgroundColor.a > 0.5, true),
+jx(color.g, coverage, flatBackgroundColor.a > 0.5, true),
+jx(color.b, coverage, flatBackgroundColor.a > 0.5, true), color.a);
 output.color = color;
 `
     }));
@@ -337,7 +352,6 @@ output.color = color;
         fsMain: compositeDenoiseDisplayMain,
         fsDefine: linearToSrgbDefine,
         uniforms: [
-            { label: 'hdrOutputEnabled', type: 'f32', data: 0 },
             { label: 'denoisedAlpha', type: 'f32', data: 0 }
         ],
         outputs: ['color'], inputs: ['colorTex', 'composedTex']
@@ -354,6 +368,7 @@ output.color = color;
         inputs: ['albedo'],
         outputs: ['albedo'],
         uniforms: auxiliaryPassUniforms,
+        csDefine: oidnAuxiliaryDefine,
         csMain: oidnAlbedoSrgbEncodeMain
     }));
     const oidnAlbedoDecodePass = scratch.get('oidnAlbedoDecodePass', () => new WGPUComputePass('OIDN albedo sRGB decode', device, {
@@ -362,12 +377,14 @@ output.color = color;
         uniforms: [...auxiliaryPassUniforms, {
                 label: 'preserveSurfaceTexture', type: 'u32', data: 0
             }],
+        csDefine: oidnAuxiliaryDefine,
         csMain: oidnAlbedoSrgbDecodeMain
     }));
     const oidnNormalSanitizePass = scratch.get('oidnNormalSanitizePass', () => new WGPUComputePass('OIDN normal sanitize', device, {
         inputs: ['normal'],
         outputs: ['normal'],
         uniforms: auxiliaryPassUniforms,
+        csDefine: oidnAuxiliaryDefine,
         csMain: oidnNormalSanitizeMain
     }));
     oidnAlbedoEncodePass.setOutputParams({ albedo: { channels: 4 } });
@@ -375,11 +392,11 @@ output.color = color;
     oidnNormalSanitizePass.setOutputParams({ normal: { channels: 4 } });
     const outputPass = scratch.get('outputPass', () => new WGPUFullQuadPass('output', device, {
         fsMain: /* wgsl */ `
-let vM = min(
+let xW = min(
 vec2i(uv2 * vec2f(colorTexRegion())),
 vec2i(colorTexRegion()) - vec2i(1)
 );
-var color = load_colorTex(vM, 0);
+var color = load_colorTex(xW, 0);
 color = vec4(color.rgb * color.a, color.a);
 output.color = color;
 `,
@@ -412,7 +429,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) {
@@ -428,14 +446,25 @@ 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,
@@ -498,7 +527,6 @@ output.color = color;
         composePass.setUniform('shadowCatcherAlpha', shadowCatcherAlpha);
         compositeDenoiseDisplayPass.setSize(renderWidth, renderHeight);
         compositeDenoiseDisplayPass.setOutputParams({ color: { format: composeColorFormat } });
-        compositeDenoiseDisplayPass.setUniform('hdrOutputEnabled', +hdrOutputActive);
         compositeDenoiseDisplayPass.setUniform('denoisedAlpha', denoiseValid && denoisedDisplayLinear ? +rayTracePass.needsDenoiseAlpha() : 0);
     }
     function snapshotInput(encoder, key, texture, exact = false) {
@@ -529,6 +557,15 @@ output.color = color;
         }
         composePass.setUniform('flatBackgroundColor', resolvedFlatBackground);
         rawOutputPass.setUniform('flatBackgroundColor', resolvedFlatBackground);
+        const aovKind = displayAovKind(output);
+        if (aovKind && sampleCount === 0) {
+            if (!execution?.aovs?.includes(aovKind))
+                throw new Error(`AOV ${aovKind} is not enabled`);
+            if (!aov.samples)
+                return;
+            finishPresentation(encoder, aov.visualize(aovKind, aovDisplayOptions, hdrOutputActive));
+            return;
+        }
         if (resolvedSamples < 1)
             return;
         prepareComposition();
@@ -536,7 +573,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');
@@ -550,17 +587,18 @@ output.color = color;
             }));
             layers.setOutputParams({ foreground: { format: 'rgba32float' }, background: { format: 'rgba32float' } });
             layers.setSize(renderWidth, renderHeight);
+            displayTrace?.push('CorrectLayers:SceneLinear');
             layers.createPass(encoder, { originalTex: getFrameInput('color'), filteredTex: denoisedTexture,
                 foregroundTex: foregroundTexture, backgroundTex: catcherBackgroundTexture });
             foregroundTexture = layers.getOutput('foreground');
             catcherBackgroundTexture = layers.getOutput('background');
         }
         const bloomEnabled = bloomIntensity > 0.0;
-        // Progressive accumulation refreshes bloom every ten samples.
-        const samplesSkipped = sampleCount < 10 || sampleCount % 10 > 0;
+        // Progressive accumulation refreshes bloom after every ten new samples,
+        // including when several samples are resolved at once.
         const bloomState = scratch.get('bloom state', () => ({ owner: undefined, settings: '', dispose() { } }));
         const bloomSettings = `${bloomThreshold}/${bloomRadius}/${+(denoiseValid && denoisedHDR)}`;
-        const needsUpdateBloom = bloomEnabled && sampleCount >= 10 && (!samplesSkipped || bloomState.owner !== targetKey || bloomState.settings !== bloomSettings);
+        const needsUpdateBloom = bloomEnabled && sampleCount >= 10 && (sampleCount - bloomSamples >= 10 || bloomState.owner !== targetKey || bloomState.settings !== bloomSettings);
         let bloomIntensityToUpdate = bloomIntensity;
         if (needsUpdateBloom) {
             if (!bloomPass) {
@@ -570,14 +608,17 @@ output.color = color;
             bloomPass.setSize(renderWidth, renderHeight);
             bloomState.owner = targetKey;
             bloomState.settings = bloomSettings;
+            bloomSamples = sampleCount;
             bloomPass.setBrightThreshold(bloomThreshold);
             bloomPass.setRadius(bloomRadius);
+            displayTrace?.push('Bloom:SceneLinear');
             bloomPass.createPass(encoder, colorTexture);
         }
         else if (bloomEnabled && sampleCount < 10) {
             bloomIntensityToUpdate = 0;
         }
         composePass.setUniform('bloomIntensity', bloomIntensityToUpdate);
+        displayTrace?.push('Compose:DisplayLinear+DisplayEncoded');
         composePass.createPass(encoder, {
             colorTex: colorTexture,
             foregroundTex: foregroundTexture,
@@ -588,6 +629,7 @@ output.color = color;
             bloomTex: bloomEnabled && bloomPass ? bloomPass.getOutput() : colorTexture
         });
         if (denoiseValid && !denoisedHDR && denoisedDisplayLinear && denoisedTexture) {
+            displayTrace?.push('Encode:DisplayEncoded');
             compositeDenoiseDisplayPass.createPass(encoder, {
                 colorTex: denoisedTexture,
                 composedTex: composePass.getOutput('denoiseColor')
@@ -596,14 +638,24 @@ output.color = color;
         let displayTexture = (denoiseValid && denoisedBuffer ? (denoisedHDR ? composePass.getOutput('color') : denoisedDisplayLinear
             ? compositeDenoiseDisplayPass.getOutput('color') : denoisedTexture) : undefined) ||
             composePass.getOutput('color');
+        if (aovKind) {
+            if (!execution?.aovs?.includes(aovKind))
+                throw new Error(`AOV ${aovKind} is not enabled`);
+            displayTexture = aov.visualize(aovKind, aovDisplayOptions, hdrOutputActive);
+        }
+        finishPresentation(encoder, displayTexture);
+    }
+    function finishPresentation(encoder, displayTexture) {
         const activeHDRPeakMeter = hdrOutputActive
             ? (hdrPeakMeter ??= scratch.get('hdrPeak', () => new WGPUHDRPeakMeter(device)))
             : undefined;
         const hdrPeakReadbackSubmitted = activeHDRPeakMeter?.encode(encoder, displayTexture, renderWidth, renderHeight) ?? false;
         if (output === 'normal' || output === 'albedo') {
+            displayTrace?.push('AOV:Raw');
             displayTexture = getFrameInput(output);
         }
         else if (output === 'shadowCatcher') {
+            displayTrace?.push('AOV:Raw');
             displayTexture = getFrameInput('shadowCatcher');
         }
         if (displayTexture.width < renderWidth || displayTexture.height < renderHeight) {
@@ -632,36 +684,46 @@ output.color = color;
             void activeHDRPeakMeter?.resolve();
         }
     }
+    function flushPostProcess() {
+        if (!postProcessPending)
+            return;
+        postProcessPending = false;
+        drawPostProcess(device.createCommandEncoder(), false, true);
+    }
     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))
+            return true;
         const resetAccumulation = isFirstFrame;
+        if (resetAccumulation)
+            aov.reset();
         if (resetAccumulation) {
+            postProcessPending = false;
+            bloomSamples = 0;
             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;
-        }
         // 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) {
@@ -687,16 +749,32 @@ output.color = color;
             needsUpdatePredicting = false;
         }
         const frameSampleCount = sampleCount;
+        const sampleTimeMs = lastGpuTraceTiming?.estimatedFullFrameTimeMs;
+        const realtime = offlineSamplesPerBatch === 0 && batchSamples;
+        const realtimeBudget = Math.min(maxTimePerTile, realtimeBatchBudgetMs);
+        if (realtime && !resetAccumulation && !isPredictingFrame && sampleTimeMs !== undefined &&
+            traceQueue.available(realtimeBudget) < Math.min(sampleTimeMs, realtimeBudget))
+            return false;
+        // Only batch a measured, unchanged full-frame workload. New cameras get
+        // their first sample immediately; expensive samples retain tiled execution.
+        const realtimeBatch = realtime && sampleCount > 0 &&
+            !resetAccumulation && !isPredictingFrame && lastGpuTraceTiming?.tileCount === 1 && sampleTimeMs !== undefined &&
+            sampleTimeMs <= realtimeBudget / 2;
+        const realtimeSamples = realtimeBatch
+            ? Math.min(64, Math.floor(traceQueue.available(realtimeBudget) / sampleTimeMs)) : 1;
+        if (realtimeBatch && realtimeSamples === 0)
+            return false;
+        const batchStarted = performance.now();
         _startRecordFrameTime(!resetAccumulation);
         const renderSampleTarget = maxSamples;
-        const batchTarget = Math.min(renderSampleTarget, sampleCount + Math.max(offlineSamplesPerBatch, 1));
+        const batchTarget = Math.min(renderSampleTarget, sampleCount + (offlineSamplesPerBatch > 0 ? offlineSamplesPerBatch : realtimeSamples));
         do {
             let { xIndex, yIndex, columns, rows, isFirstTile, isLastTile, samplesPerFrame } = (tileRenderWithPredict || tileRender).nextTile(elapsedTileTime);
             rayTraceOutputPass.setSampleTileGrid(columns, rows);
-            if (offlineSamplesPerBatch > 0 && columns * rows === 1) {
+            if ((offlineSamplesPerBatch > 0 || realtimeBatch) && columns * rows === 1) {
                 samplesPerFrame = batchTarget - sampleCount;
             }
-            else if (!allowMultipleSamplesPerFrame) {
+            else if (!batchSamples) {
                 samplesPerFrame = 1;
             }
             if (columns * rows === 1) {
@@ -708,11 +786,21 @@ output.color = color;
                     sample(sampleCount === 0, [1, 1]);
                     sampleCount++;
                     samplesSubmitted++;
+                    if (realtime && !isPredictingFrame && sampleTimeMs !== undefined)
+                        traceQueue.track(sampleTimeMs);
+                    if (realtimeBatch) {
+                        // Encoding many tiny samples must also leave the main thread free
+                        // to receive camera input. Yield before encoding another batch.
+                        if (performance.now() - batchStarted >= 4)
+                            break;
+                    }
                 }
             }
             else {
                 rayTracePass.setSampleTiles(columns, rows, xIndex, yIndex);
                 sample(sampleCount === 0 && isFirstTile, [columns, rows]);
+                if (realtime && !isPredictingFrame && sampleTimeMs !== undefined)
+                    traceQueue.track(sampleTimeMs / (columns * rows));
                 if (isLastTile)
                     sampleCount++;
             }
@@ -727,7 +815,14 @@ output.color = color;
             sampleCount = 0;
             return false;
         }
-        if (sampleCount !== frameSampleCount && (!deferPostProcess || sampleCount >= renderSampleTarget)) {
+        if (sampleCount !== frameSampleCount && execution?.aovs?.length) {
+            rayTracePass.renderAovs(aov, camera, sampleCount, execution.aovSamples ?? 16, execution.aovs);
+        }
+        if (sampleCount !== frameSampleCount && realtime && realtimeDeferPostProcess && sampleCount < renderSampleTarget) {
+            postProcessPending = true;
+        }
+        else if (sampleCount !== frameSampleCount && (!deferPostProcess || sampleCount >= renderSampleTarget)) {
+            postProcessPending = false;
             const encoder = device.createCommandEncoder();
             drawPostProcess(encoder, sampleCount >= renderSampleTarget, true);
         }
@@ -759,6 +854,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);
@@ -856,7 +952,6 @@ output.color = color;
             hdrPeakMeter?.reset();
         }
         compositeDenoiseDisplayPass.setOutputParams({ color: { format: composeColorFormat } });
-        compositeDenoiseDisplayPass.setUniform('hdrOutputEnabled', hdrOutputActive ? 1 : 0);
         composePass.setUniform('hdrOutputEnabled', hdrOutputActive ? 1 : 0);
         return wasActive !== hdrOutputActive;
     }
@@ -893,6 +988,7 @@ output.color = color;
         jnlmPass ??= scratch.get('jnlm', () => new WGPUJNLMDenoisePass(device));
         const rayBuffers = rayTracePass.getOutputBuffer();
         const encoder = device.createCommandEncoder({ label: 'JNLM denoise' });
+        displayTrace?.push('Denoise:DisplayLinear');
         const output = jnlmPass.encode(encoder, {
             width: renderWidth,
             height: renderHeight,
@@ -917,7 +1013,7 @@ output.color = color;
             return completed;
         });
     }
-    function performCustomDenoise(denoiser, schedule, signal) {
+    function performCustomDenoise(denoiser, schedule, signal, requestedAovs = []) {
         const generation = denoiseGeneration;
         const controller = activeCustomController = new AbortController();
         const abort = () => controller.abort();
@@ -932,7 +1028,15 @@ output.color = color;
             const albedo = copyGuide('Custom albedo', getFrameInput('albedo'), true);
             const normal = copyGuide('Custom normal', getFrameInput('normal'), true);
             const output = scratch.get('Custom output', () => new WGPUScratchBuffer(device)).get(width * height * 16, true);
-            await denoiser.denoise({ device, width, height, color, albedo, normal, output }, { signal: controller.signal, schedule });
+            const aovs = requestedAovs.length ? aov.snapshot(requestedAovs) : undefined;
+            displayTrace?.push('Denoise:SceneLinear');
+            try {
+                await denoiser.denoise({ device, width, height, color, albedo, normal, output, aovs }, { signal: controller.signal, schedule });
+            }
+            finally {
+                if (aovs)
+                    void device.queue.onSubmittedWorkDone().catch(() => undefined).then(() => aov.releaseSnapshot(aovs));
+            }
             if (controller.signal.aborted || disposed || generation !== denoiseGeneration)
                 return false;
             const coverage = scratch.get('custom coverage', () => new WGPUComputePass('Custom coverage', device, {
@@ -965,8 +1069,11 @@ output.color = color;
         cancelDenoise();
         if (isFirstFrame || sampleCount < 1)
             return Promise.resolve(false);
+        if (output !== 'final' && output !== 'shadow')
+            return Promise.resolve(true);
+        flushPostProcess();
         if (attachedDenoiser.kind === 'custom')
-            return performCustomDenoise(attachedDenoiser.denoiser, denoiseSchedule, signal);
+            return performCustomDenoise(attachedDenoiser.denoiser, denoiseSchedule, signal, attachedDenoiser.aovs);
         denoisedHDR = false;
         if (attachedDenoiser.kind === 'jnlm')
             return performJNLMDenoise(attachedDenoiser.denoiser);
@@ -991,7 +1098,7 @@ output.color = color;
                 wholeImage: denoiseSchedule === 'every-sample'
             } : {}),
             // A preview frame is one whole-image pass. Settled images can take many
-            // tiles; oidn-web 0.5 runs those back to back by default, which starves
+            // tiles; oidn-webgpu runs those back to back by default, which starves
             // the page at 4K, so pace them to display frames instead.
             scheduling: denoiseSchedule === 'every-sample' ? 'event-loop' : 'animation-frame'
         };
@@ -1081,6 +1188,7 @@ output.color = color;
                 return Promise.resolve();
             // Snapshot the complete raw composition; never feed a previous denoise
             // back into the network during progressive updates.
+            displayTrace?.push('Denoise:DisplayLinear');
             return runOIDNPhase(generation, (finish, fail) => denoiser.tileExecute({
                 ...convergingTileOptions,
                 color: { data: colorInput, ...size },
@@ -1189,35 +1297,59 @@ output.color = color;
             diagnosticsReadbackPromise
         ]).then(() => {
             rayTracePass.releaseTarget(targetKey);
+            aov.dispose();
             denoisedBuffer?.destroy();
             presentationTexture?.destroy();
             displayPostProcess.dispose();
             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();
-            execution = { ...settings };
+            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;
+            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
+            // reapplies the current channel when the new image is presented.
+            const displayedAov = displayAovKind(output);
+            if (displayedAov && !settings.aovs?.includes(displayedAov))
+                output = 'final';
+            if (previousMask && !nextMask) {
+                aov.dispose();
+                aov.history.clear();
+                aov.width = aov.height = 0;
+                aov.reset();
+            }
             maxTimePerTile = Math.max(1, settings.timeBudgetMs);
-            allowMultipleSamplesPerFrame = settings.allowMultipleSamplesPerFrame;
+            batchSamples = settings.batchSamples;
             tileRender.setDesiredMsPerTile(maxTimePerTile);
             tileRender.setMaxTiles(settings.maxTiles);
             tileRenderWithPredict?.setDesiredMsPerTile(maxTimePerTile);
@@ -1228,6 +1360,11 @@ output.color = color;
         canCompleteSampleWithin(timeBudgetMs) {
             return (lastGpuTraceTiming?.estimatedFullFrameTimeMs ?? elapsedFrameTime) <= timeBudgetMs;
         },
+        setRealtimeBatchBudget(milliseconds) { realtimeBatchBudgetMs = milliseconds; },
+        setRealtimeDeferPostProcess(defer) { realtimeDeferPostProcess = defer; },
+        getRealtimeSampleTime() { return lastGpuTraceTiming?.estimatedFullFrameTimeMs; },
+        getRealtimeTileTime() { return lastGpuTraceTiming?.tileTimePerSampleMs; },
+        whenTraceAvailable() { return traceQueue.whenAvailable(); },
         get presentationComplete() { return !!presentationTexture; },
         get presentationDenoised() { return presentationDenoised; },
         present() {
@@ -1242,13 +1379,14 @@ output.color = color;
         getMemory() {
             return {
                 width: renderWidth, height: renderHeight,
-                bytes: rayTracePass.getTargetMemoryBytes(targetKey) + rayTraceOutputPass.getMemoryBytes() + textureBytes(presentationTexture) + displayPostProcess.getMemoryBytes() + (denoisedBuffer?.size ?? 0)
+                bytes: aov.bytes + rayTracePass.getTargetMemoryBytes(targetKey) + rayTraceOutputPass.getMemoryBytes() + textureBytes(presentationTexture) + displayPostProcess.getMemoryBytes() + (denoisedBuffer?.size ?? 0)
             };
         },
         isFirstFrame() {
             return isFirstFrame;
         },
         restartSamples() {
+            aov.reset();
             // Input edits reset accumulation, not learned throughput. Re-arming a
             // hidden probe here starves continuously changing scenes of visible samples.
             tileTimingGeneration++;
@@ -1257,16 +1395,17 @@ output.color = color;
             denoiseValid = false;
             presentationDenoised = false;
             resolvedSamples = 0;
+            postProcessPending = false;
+            bloomSamples = 0;
             (tileRenderWithPredict || tileRender).reset();
             isPredictingFrame = false;
             isFirstFrame = true;
             sampleCount = 0;
         },
         getOutputTexture(kind) {
-            if (resolvedSamples < 1)
-                return;
+            flushPostProcess();
             if (kind === 'hdr')
-                return getFrameInput('color');
+                return resolvedSamples > 0 ? getFrameInput('color') : undefined;
             return displayPostProcess.output ?? presentationTexture;
         },
         applyPostProcesses(passes, render) {
@@ -1275,8 +1414,9 @@ output.color = color;
         },
         trace,
         drawPostProcess() {
-            const encoder = device.createCommandEncoder();
-            drawPostProcess(encoder, true);
+            const resolve = postProcessPending;
+            postProcessPending = false;
+            drawPostProcess(device.createCommandEncoder(), true, resolve);
         },
         performDenoise,
         cancelDenoise,
@@ -1291,9 +1431,11 @@ output.color = color;
             const bytesPerRow = Math.ceil(width * 16 / 256) * 256;
             const buffer = device.createBuffer({ size: bytesPerRow * height, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ });
             const encoder = device.createCommandEncoder();
-            readbackPass.setSize(width, height);
-            readbackPass.createPass(encoder, { inputTex: image });
-            encoder.copyTextureToBuffer({ texture: readbackPass.getOutput('color') }, { buffer, bytesPerRow }, { width, height });
+            const presentationReadback = hdrOutputActive && displayAovKind(output) ? scratch.get('AOV encoded readback', () => new WGPUFullQuadPass('AOV encoded readback', device, { textureWillBeRead: true, inputs: ['inputTex'], outputs: ['color'], fsMain: `let c=load_inputTex(uv,0);let rgb=select(1.055*pow(max(c.rgb,vec3f(0.0)),vec3f(1.0/2.4))-0.055,12.92*c.rgb,c.rgb<=vec3f(0.0031308));output.color=vec4f(rgb,c.a);` })) : readbackPass;
+            presentationReadback.setOutputParams({ color: { format: 'rgba32float' } });
+            presentationReadback.setSize(width, height);
+            presentationReadback.createPass(encoder, { inputTex: image });
+            encoder.copyTextureToBuffer({ texture: presentationReadback.getOutput('color') }, { buffer, bytesPerRow }, { width, height });
             device.queue.submit([encoder.finish()]);
             try {
                 await buffer.mapAsync(GPUMapMode.READ);
@@ -1308,7 +1450,46 @@ output.color = color;
                 buffer.destroy();
             }
         },
+        aovReady(kind) { return !!execution?.aovs?.includes(kind) && aov.samples > 0; },
+        getAovSamples() { return aov.samples; },
+        restartAovs() { aov.reset(); },
+        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);
+        },
+        async readAov(kind) {
+            if (!execution?.aovs?.includes(kind) || !aovCamera || (sampleCount < 1 && aov.samples < 1))
+                throw new Error('AOV output is not ready');
+            for (;;) {
+                if (disposed)
+                    throw new Error('AOV compilation was interrupted');
+                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), execution.aovSamples ?? 16, execution.aovs))
+                    break;
+                // Display frames stop on a hidden page, but compilation still completes.
+                await new Promise(resolve => setTimeout(resolve, 16));
+            }
+            return aov.read(kind);
+        },
         async readOutput(kind) {
+            flushPostProcess();
             rawOutputPass.setUniform('flatBackgroundColor', resolvedFlatBackground);
             const width = renderWidth, height = renderHeight;
             const bytesPerRow = Math.ceil(width * 16 / 256) * 256;
@@ -1377,6 +1558,38 @@ output.color = color;
         getTotalSamplesRendered() {
             return sampleCount;
         },
+        /** @internal */
+        _displayParity() {
+            return {
+                record(trace) { displayTrace = trace; },
+                load(input) {
+                    cancelDenoise();
+                    clearDenoisedOutput();
+                    setSize(input.width, input.height);
+                    rayTracePass.useTarget(targetKey);
+                    rayTracePass.setSize(renderWidth, renderHeight, screenWidth / screenHeight);
+                    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);
+                        shadow.set(input.moments.subarray(i * 4, i * 4 + 4), i * 12 + 8);
+                    }
+                    for (const [buffer, data] of [[buffers.color, input.color], [buffers.albedo, input.albedo],
+                        [buffers.normal, input.normal], [buffers.shadowCatcher, shadow]])
+                        device.queue.writeBuffer(buffer, 0, data);
+                    sampleCount = resolvedSamples = input.samples;
+                    resolvedHasShadowCatcher = input.catcher;
+                    isFirstFrame = false;
+                    postProcessPending = false;
+                    bloomSamples = 0;
+                    rayTraceOutputPass.setSampleCount(sampleCount);
+                    rayTraceOutputPass.setSampleTileGrid(1, 1);
+                    const encoder = device.createCommandEncoder();
+                    rayTraceOutputPass.createPass(encoder, buffers, resolvedHasShadowCatcher);
+                    device.queue.submit([encoder.finish()]);
+                }
+            };
+        },
         getDiagnostics() {
             return {
                 ...rayTracePass.getDiagnostics(),
@@ -1421,6 +1634,7 @@ output.color = color;
         setOnSampleRendered(cb) {
             sampleRenderedCallback = cb;
         },
+        setAovDisplayOptions(options) { aovDisplayOptions = { ...options, depthRange: [...options.depthRange] }; },
         setOutput(nextOutput) {
             if (output === nextOutput)
                 return false;
@@ -1432,7 +1646,8 @@ output.color = color;
 }
 /** Independent render targets, without preview or presentation policy. */
 export function makeWGPURenderTargets(canvas, device, options = {}) {
-    const rayTracePass = new WGPURayTracePass(device);
+    const rayTracePass = new WGPURayTracePass(device, options.materialTextures);
+    const traceQueue = new GPUTraceQueue(device.queue);
     const customJobs = new Set();
     const scratch = new ScratchPool(work => {
         // A cancelled custom filter can keep submitting GPU work until its promise settles.
@@ -1443,7 +1658,7 @@ export function makeWGPURenderTargets(canvas, device, options = {}) {
     });
     const surface = scratch.get('canvas', () => new WGPUCanvasSurface(canvas, device, options.presentationFormat ?? navigator.gpu.getPreferredCanvasFormat()));
     return makeRenderPipeline(rayTracePass, () => {
-        const target = makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scratch, customJobs);
+        const target = makeWGPUAccumulationTarget(canvas, device, rayTracePass, surface, scratch, customJobs, traceQueue);
         return target;
     }, false, scratch);
 }