@meimu/mutracer 0.2.0 → 0.3.0

package/lib/renderer/WGPURenderingPipeline.js

@@ -3,7 +3,6 @@ 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 { DisplayPostProcess } from './DisplayPostProcess.js';
 import { customDenoiseLayersMain, customDenoiseCoverageMain } from './wgsl/customDenoise.wgsl.js';
 import { WGPUCanvasSurface } from './WGPUCanvasSurface.js';
@@ -28,16 +27,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 = 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 linear = sS(filtered.rgb);
+let linear = sP(filtered.rgb);
 var result = linear;
-let jD = textureLoad(in_rawAlbedo, vec2i(globalId.xy), 0).a;
+let jj = textureLoad(in_rawAlbedo, vec2i(globalId.xy), 0).a;
 if (preserveSurfaceTexture != 0u) {
 
 
@@ -45,33 +44,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 nS = 0.0;
 for (var y = -1; y <= 1; y++) {
 for (var x = -1; x <= 1; x++) {
-let vw = textureLoad(in_rawNormal,
+let vI = 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(vI.rgb * 2.0 - 1.0 + vec3f(1e-8));
+nS = max(nS,
+max(1.0 - dot(n, nn), abs(center.a - vI.a)));
 }
 }
-let vO = smoothstep(0.02, 0.1, oc);
+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, vO);
+result = mix(raw, linear, wc);
 }
-out_albedo[index] = vec4f(result, jD);
+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(rL(in_normal[index].rgb), 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,
@@ -100,6 +99,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 +111,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();
@@ -235,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;
@@ -261,9 +266,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);
+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;
 `
     }));
@@ -387,11 +392,11 @@ output.color = color;
     oidnNormalSanitizePass.setOutputParams({ normal: { channels: 4 } });
     const outputPass = scratch.get('outputPass', () => new WGPUFullQuadPass('output', device, {
         fsMain: /* wgsl */ `
-let xs = min(
+let xW = min(
 vec2i(uv2 * vec2f(colorTexRegion())),
 vec2i(colorTexRegion()) - vec2i(1)
 );
-var color = load_colorTex(xs, 0);
+var color = load_colorTex(xW, 0);
 color = vec4(color.rgb * color.a, color.a);
 output.color = color;
 `,
@@ -424,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) {
@@ -440,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,
@@ -556,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');
@@ -674,19 +691,25 @@ output.color = color;
         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();
@@ -696,20 +719,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) {
@@ -840,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);
@@ -1289,24 +1304,30 @@ 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))
@@ -1341,7 +1362,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; },
@@ -1434,9 +1456,13 @@ 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);
@@ -1444,11 +1470,21 @@ output.color = color;
         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), 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);
         },
@@ -1532,7 +1568,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);