@meimu/mutracer 0.2.0 → 0.3.0

package/lib/renderer/WGPURayTracePass.js

@@ -1,3 +1,11 @@
+import { causticDiagnostics } from './causticDiagnostics.js';
+import { WGPUPhotonMap, photonRadius } from './WGPUPhotonMap.js';
+import { defaultPhotonMapPhotons } from './wgsl/photonMap.compute.js';
+import { researchTransport } from './researchTransport.js';
+import { causticEmissionTable } from './causticEmission.js';
+import { WGPUCausticLightPass } from './WGPUCausticLightPass.js';
+import { causticLightCompute } from './wgsl/causticLight.compute.js';
+import { causticCasterSpheres, hasStochasticCausticCaster, causticCasterSphere, isCausticSpecular } from './caustics.js';
 import { AovPrimitiveCache } from './AovPrimitiveCache.js';
 import { packAovScene } from './aovScene.js';
 import { aovMask } from './aov.js';
@@ -46,7 +54,7 @@ import { updateMeshInstances, updateMeshInstanceTransforms } from './prepareMesh
 import { buildTLAS, concatBLASBuffers, getTraversalStackSizes, refitBLAS, refitTLAS } from './bvhAccel.js';
 import { isTextureDataSource } from '../scene/Texture.js';
 import { DEFAULT_BEVEL_SAMPLES, DEFAULT_DIRECT_LIGHT_CANDIDATES, normalizeBevelSamples, normalizeDirectLightCandidates } from './RenderingPipeline.js';
-import { EmissiveTriangleCache, LightChoiceBuffer, estimateEnvironmentPower, } from './lightSampling.js';
+import { EmissiveTriangleCache, LightChoiceBuffer, estimateEnvironmentPower } from './lightSampling.js';
 import { getOpenPbrEnergyLutData, OPENPBR_ENERGY_LUT_HEIGHT, OPENPBR_ENERGY_LUT_WIDTH } from './openPbrEnergyLut.js';
 import { offlineAdaptiveCompute } from './wgsl/offlineAdaptive.compute.js';
 import { normalizeOfflineAdaptiveSamplingOptions } from './OfflineAdaptiveSampling.js';
@@ -78,6 +86,10 @@ function joinWebGPUErrors(...errors) {
             .filter(Boolean))
     ].join('\n');
 }
+const MAX_TRACE_VARIANTS = 32;
+// Requests are cheap but drivers are not, and a running compilation cannot be cancelled.
+const MAX_CONCURRENT_COMPILES = 2;
+const MAX_QUEUED_COMPILES = 4;
 function shaderCompilationNow() {
     return typeof performance === 'undefined' ? Date.now() : performance.now();
 }
@@ -113,6 +125,16 @@ class WGPURayTracePass {
     _width = 0;
     _height = 0;
     _meshes = [];
+    _causticKey = '';
+    _photonMapping = false;
+    _photonMap;
+    _causticLight;
+    _causticSettings;
+    _causticPerspective = true;
+    _causticCameraScale = 1;
+    _causticBounds = [0, 0, 0, 0];
+    _transport;
+    _lightTracing = false;
     _sceneEnvironment = new SceneEnvironmentCache();
     _rectLightTextures = new RectLightTextureTracker();
     _analyticLights = [];
@@ -147,6 +169,8 @@ class WGPURayTracePass {
         if (!output)
             return;
         this._targetOutputs.delete(target);
+        this._causticLight?.release(target);
+        this._photonMap?.release(target);
         for (const buffer of output.buffers)
             buffer.destroy();
         if (this._activeTarget === target) {
@@ -155,17 +179,23 @@ class WGPURayTracePass {
         }
     }
     getTargetMemoryBytes(target) {
-        return this._targetOutputs.get(target)?.buffers.reduce((sum, buffer) => sum + buffer.size, 0) ?? 0;
+        return ((this._targetOutputs.get(target)?.buffers.reduce((sum, buffer) => sum + buffer.size, 0) ?? 0) +
+            (this._causticLight?.bytes(target) ?? 0) +
+            (this._photonMap?.bytes(target) ?? 0));
     }
     useTarget(target) {
+        if (this._photonMapping && this._activeTarget !== target)
+            this._needsPhotonTargetBindGroups = true;
         this._activeTarget = target;
         const output = this._targetOutputs.get(target);
-        [this._outColorBuffer, this._outNormalBuffer, this._outAlbedoBuffer, this._outShadowCatcherBuffer] = output?.buffers ?? [];
+        [this._outColorBuffer, this._outNormalBuffer, this._outAlbedoBuffer, this._outShadowCatcherBuffer] =
+            output?.buffers ?? [];
         if (output?.bindGroup && output.pipeline === this._rayTracePipeline && this._rayTraceBindGroups) {
             this._rayTraceBindGroups[this._bindless ? 2 : 3] = output.bindGroup;
+            this._needsUpdateOutputBindGroup = false;
         }
         else {
-            this._needsUpdateBindGroups = true;
+            this._needsUpdateOutputBindGroup = true;
         }
     }
     _outColorBuffer;
@@ -212,22 +242,25 @@ class WGPURayTracePass {
     _skyBaker;
     _backgroundImageSource;
     _backgroundTex;
-    _rayTracePipelineLayout;
     _rayTraceBindGroups;
+    _photonEmissionGroups;
     _blasLayoutMask = 1;
-    _compiledBlasLayoutMask = 0;
-    _compiledAnisotropyDirections = false;
-    _compiledCoatNormals = false;
-    _compiledHasAlpha = true;
-    _compiledSceneHasAlpha = true;
     _alphaBlendStrategy = 'stochastic';
     _constants = initialSceneConstants();
     _retainedShaderCapabilities;
     _retainedShaderStructure;
     _shaderCapabilities = new WGPUShaderCapabilities();
-    _prevPipelineConstants = {};
-    _prevDefinesCode = '';
-    _prevPipelineInputs;
+    _targetTransport = new WeakMap();
+    _traceVariants = new Map();
+    _queuedCompiles = [];
+    _activeCompiles = 0;
+    _traceModules = new Map();
+    _requestedVariant;
+    _activeVariant;
+    _activeInputs;
+    _awaitingRetirement;
+    _resourceError;
+    _aovPipelinesFailed = false;
     _hasTransmission = false;
     _hasShadowCatcher = false;
     _hasDisplacement = false;
@@ -242,19 +275,20 @@ class WGPURayTracePass {
     _apertureRadius = 0;
     _focusDistance = 10;
     _needsUpdateBindGroups = true;
-    _computeShaderModule;
+    // Photon maps are per target. Switching targets only rebinds them, which
+    // must not send steady frames through the asynchronous pipeline path.
+    _needsPhotonTargetBindGroups = false;
+    // Target selection is not a scene-resource edit. A stale fallback must not
+    // leave global bindings dirty after switching back to a prepared target.
+    _needsUpdateOutputBindGroup = false;
     _aovPipelines = new WeakMap();
     _depthCompute;
     _depthTracePipeline;
     _depthPipeline;
     _shaderCache;
     _debugBVHBuffer;
-    _isCompilingShader = false;
-    _shaderCompilationDiagnostics;
-    _pipelineError;
     // Fold scene invariants before backend inlining; runtime edits use uniforms.
     _bakePipelineConstants = true;
-    _failedPipelineSignature;
     constructor(device, _textureSelection = { requested: 'atlas' }) {
         this._textureSelection = _textureSelection;
         this._device = device;
@@ -298,8 +332,14 @@ class WGPURayTracePass {
         device.queue.writeTexture({ texture: this._adaptiveSamplingTexture }, new Float32Array([Number.MAX_SAFE_INTEGER]), { bytesPerRow: 4 }, [1, 1]);
     }
     getOutputBuffer() {
+        // Another render may have traced since this target's samples were written.
+        const transport = this._targetTransport.get(this._activeTarget) ?? 0;
         return {
             color: this._outColorBuffer,
+            ...(transport & 2 || ((this._transport?.debugGroup ?? -1) >= 0 || causticDiagnostics.debugGroup >= 0) ? { wideHdr: true } : {}),
+            ...(transport & 1 && this._causticLight?.get(this._activeTarget)
+                ? { caustic: this._causticLight.get(this._activeTarget) }
+                : {}),
             normal: this._outNormalBuffer,
             albedo: this._outAlbedoBuffer,
             shadowCatcher: this._outShadowCatcherBuffer
@@ -494,12 +534,26 @@ class WGPURayTracePass {
                 varianceBuffer.destroy();
         }
     }
-    _createPipelineLayout() {
+    _createPipelineLayout(bindless, photonMapping) {
         const descriptor = {
             label: 'Ray Trace Pipeline Layout',
-            bindGroupLayouts: (this._bindless ? bindlessBindGroupLayouts() : rayTraceBindGroupLayouts()).map(layout => this._shaderCache.createBindGroupLayout(layout))
+            bindGroupLayouts: (bindless ? bindlessBindGroupLayouts() : rayTraceBindGroupLayouts()).map((layout, index) => {
+                if (photonMapping && index === (bindless ? 0 : 1))
+                    layout = {
+                        ...layout,
+                        entries: [
+                            ...layout.entries,
+                            ...[11, 12].map((binding) => ({
+                                binding: binding + (bindless ? 4 : 0),
+                                visibility: GPUShaderStage.COMPUTE,
+                                texture: { sampleType: 'uint' }
+                            }))
+                        ]
+                    };
+                return this._shaderCache.createBindGroupLayout(layout);
+            })
         };
-        this._rayTracePipelineLayout = this._shaderCache.createPipelineLayout(this._bindless ? resourceTableLayout(descriptor) : descriptor);
+        return this._shaderCache.createPipelineLayout(bindless ? resourceTableLayout(descriptor) : descriptor);
     }
     _updateGPUBuffer(label, gpuBuffer, data, minSize = WGPU_SCENE_BUFFER_MIN_BYTES) {
         const device = this._device;
@@ -527,22 +581,46 @@ class WGPURayTracePass {
             usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
         });
     }
-    async updatePipeline() {
-        if (this._isCompilingShader) {
+    _preparePhotonTarget() {
+        if (!this._photonMapping)
             return;
+        this._photonMap ??= new WGPUPhotonMap(this._device);
+        const before = this._photonMap.get(this._activeTarget)?.data;
+        const requested = this._causticSettings?.photonMapping;
+        const n = typeof requested === 'object' ? requested.photonsPerSample : undefined;
+        const after = this._photonMap.ensure(this._activeTarget, Number.isFinite(n) && n > 0 ? n : defaultPhotonMapPhotons(this._width, this._height, causticDiagnostics.photonCountDivisor));
+        if (before !== after.data)
+            this._needsUpdateBindGroups = true;
+    }
+    /**
+     * Prepares the pipeline for the settings currently written to this pass.
+     * Everything except compilation runs synchronously, and compilation only
+     * writes to its own variant. Renders with different settings can therefore
+     * interleave without invalidating each other. Returns a promise while the
+     * requested state waits on the GPU; undefined means nothing is outstanding.
+     */
+    updatePipeline() {
+        if (this._disposed)
+            return;
+        if (this._needsUpdateMeshData || this._needsUpdateMeshMembership || this._pendingGeometryUpdates.size ||
+            this._needsRefitTLAS || this._dirtyColorMeshes.size || this._pendingMaterialUpdate || this._needsUpdateLightSamplingData) {
+            // A failure can have the same shader signature as its repaired scene.
+            // Retry after authored updates, while keeping an unchanged failure idle.
+            this._resourceError = undefined;
+            for (const [signature, variant] of this._traceVariants)
+                if (variant.status === 'failed')
+                    this._traceVariants.delete(signature);
+            if (this._aovPipelinesFailed) {
+                this._aovPipelines = new WeakMap();
+                this._aovPipelinesFailed = false;
+            }
         }
-        // Set this before any synchronous preparation. updatePipeline is called
-        // without awaiting it, so a preparation error must not let createPass run
-        // with an undefined pipeline in the same frame.
-        this._isCompilingShader = true;
-        let attemptedPipelineSignature;
-        let compilationStartedAt;
-        let pipelineCompilationStartedAt;
+        this._awaitingRetirement = this._bindless?.retirement;
+        if (this._awaitingRetirement)
+            return this._awaitingRetirement;
+        if (this._resourceError)
+            return;
         try {
-            if (this._bindless?.retirement)
-                await this._bindless.retirement;
-            if (this._disposed)
-                return;
             if (this._needsUpdateMeshData) {
                 this._updateMeshData();
             }
@@ -557,29 +635,49 @@ class WGPURayTracePass {
                 this._updateMeshColors();
             if (this._pendingMaterialUpdate)
                 this._updateMaterialData();
+            this._setCaustics(this._causticSettings);
             if (this._needsUpdateLightSamplingData) {
                 this._updateLightSamplingData();
             }
-            const device = this._device;
-            const pipelineInputs = JSON.stringify([this._constants, this._hasDisplacement,
-                this._alphaBlendStrategy, this._blasLayoutMask, this._bakePipelineConstants]);
+            this._setCaustics(this._causticSettings);
+            if (this._lightTracing || this._photonMapping)
+                this._causticBounds = causticCasterSphere(this._meshes);
+            this._targetTransport.set(this._activeTarget, (+this._lightTracing) | (+this._photonMapping << 1));
+            this._preparePhotonTarget();
+            const pipelineInputs = JSON.stringify([
+                this._constants,
+                this._hasDisplacement,
+                this._alphaBlendStrategy,
+                this._blasLayoutMask,
+                this._bakePipelineConstants,
+                this._causticKey,
+                !!this._bindless
+            ]);
             // Steady rendering must not repeat capability selection and cache-key
             // preparation. Dirty resources still take the normal bind-group path.
-            if (pipelineInputs === this._prevPipelineInputs && this._rayTracePipeline &&
-                this._rayTraceBindGroups && !this._needsUpdateBindGroups)
+            if (pipelineInputs === this._activeInputs &&
+                this._rayTracePipeline &&
+                this._rayTraceBindGroups &&
+                !this._needsUpdateBindGroups) {
+                if (this._needsPhotonTargetBindGroups || this._needsUpdateOutputBindGroup) {
+                    this._needsPhotonTargetBindGroups = false;
+                    this._needsUpdateOutputBindGroup = false;
+                    this._updateBindGroups();
+                }
+                this._requestedVariant = this._activeVariant;
                 return;
+            }
             this._rtUniform.views.sceneFeatureFlags[0] = wgpuSceneFeatureFlags(this._constants);
             const requiredCapabilities = retainedShaderCapabilities(this._constants);
             const constants = { ...this._constants, ...requiredCapabilities };
-            const hasAlpha = Boolean(constants.HAS_ALPHA_BLEND) &&
-                this._alphaBlendStrategy === 'deterministic-source-over';
+            const hasAlpha = Boolean(constants.HAS_ALPHA_BLEND) && this._alphaBlendStrategy === 'deterministic-source-over';
             const hasSceneAlpha = Boolean(constants.HAS_ALPHA);
             const pipelineConstantsKeys = wgpuPipelineConstantKeys(constants);
-            const defineCode = WGPU_SHADER_DEFINE_KEYS
-                .map((key) => `const ${key} = ${constants[key]};`)
-                .join('\n');
+            const defineCode = WGPU_SHADER_DEFINE_KEYS.map((key) => `const ${key} = ${constants[key]};`).join('\n');
             const structure = {
                 hasDisplacement: this._hasDisplacement,
+                caustics: this._causticKey,
+                bindless: !!this._bindless,
                 hasAlpha,
                 hasSceneAlpha,
                 hasAnisotropyDirections: Boolean(constants.USE_ANISOTROPY_DIRECTIONS),
@@ -588,10 +686,11 @@ class WGPURayTracePass {
                 bakePipelineConstants: this._bakePipelineConstants
             };
             const structureKey = JSON.stringify({
-                ...structure, defineCode,
+                ...structure,
+                defineCode,
                 constants: pipelineConstantsKeys
-                    .filter(key => !(key in requiredCapabilities))
-                    .map(key => [key, constants[key]])
+                    .filter((key) => !(key in requiredCapabilities))
+                    .map((key) => [key, constants[key]])
             });
             // Prefer an existing compatible pipeline, including an earlier lean
             // variant. Only grow the current variant when it cannot cover an edit;
@@ -599,265 +698,255 @@ class WGPURayTracePass {
             const capabilities = this._shaderCapabilities.find(structureKey, requiredCapabilities) ??
                 retainedShaderCapabilities(this._constants, structureKey === this._retainedShaderStructure ? this._retainedShaderCapabilities : undefined);
             Object.assign(constants, capabilities);
-            const pipelineSignature = JSON.stringify({
+            // Runtime feature values live in uniforms, so edits can share a pipeline
+            // as long as its compiled defines and overrides are the same.
+            const signature = JSON.stringify({
                 ...structure,
-                constants: Object.keys(constants).sort().map(key => [key, constants[key]])
+                defineCode,
+                constants: pipelineConstantsKeys.map((key) => [key, constants[key]])
             });
-            attemptedPipelineSignature = pipelineSignature;
-            if (pipelineSignature === this._failedPipelineSignature) {
+            const variant = this._traceVariants.get(signature) ??
+                this._startTraceVariant(signature, constants, { hasAlpha, hasSceneAlpha, defineCode, pipelineConstantsKeys, structureKey, capabilities });
+            this._requestedVariant = variant;
+            if (variant.status === 'pending') {
+                this._requestQueuedCompile(variant);
+                return variant.settled;
+            }
+            if (variant.status === 'failed')
                 return;
+            this._installTraceVariant(variant, pipelineInputs);
+        }
+        catch (error) {
+            this._resourceError = error;
+            this._needsUpdateBindGroups = true;
+            console.error('Failed to update WebGPU ray tracing resources.', error);
+        }
+    }
+    /** Runs only for a ready variant, without yielding, so tracing can start in this call. */
+    _installTraceVariant(variant, pipelineInputs) {
+        if (this._activeVariant !== variant) {
+            this._activeVariant = variant;
+            this._rayTracePipeline = variant.pipeline;
+            this._depthCompute = variant.depthCompute;
+            this._needsUpdateBindGroups = true;
+        }
+        const emission = () => causticEmissionTable(this._analyticLights, this._emissiveTriangles, this._causticBounds[3], this._envImageSource && 'sky' in this._envImageSource
+            ? proceduralEnvironmentPower(this._envImageSource)
+            : estimateEnvironmentPower(this._envImageSource));
+        const casters = () => causticDiagnostics.aggregateCasters ? [this._causticBounds] : causticCasterSpheres(this._meshes);
+        if (this._lightTracing && this._causticLight) {
+            this._causticLight.setDistribution(casters(), emission());
+            this._causticLight.use(variant.lightEmitter);
+        }
+        if (this._photonMapping && this._photonMap) {
+            this._photonMap.emission.setDistribution(casters(), emission());
+            this._photonMap.emission.use(variant.photonEmitter);
+        }
+        // TODO rebind when lights, materials, bvh changed.
+        if (this._needsUpdateBindGroups || this._needsPhotonTargetBindGroups || this._needsUpdateOutputBindGroup) {
+            this._needsUpdateBindGroups = false;
+            this._needsPhotonTargetBindGroups = false;
+            this._needsUpdateOutputBindGroup = false;
+            this._updateBindGroups();
+        }
+        this._retainedShaderCapabilities = variant.capabilities;
+        this._retainedShaderStructure = variant.structureKey;
+        this._shaderCapabilities.remember(variant.structureKey, variant.capabilities);
+        this._activeInputs = pipelineInputs;
+    }
+    /** Snapshots everything compilation needs. The task must not read mutable pass state afterwards. */
+    _startTraceVariant(signature, constants, shader) {
+        const bake = this._bakePipelineConstants, bindless = this._bindless;
+        const hasDisplacement = this._hasDisplacement, blasLayoutMask = this._blasLayoutMask;
+        const lightTracing = this._lightTracing, photonMapping = this._photonMapping;
+        const causticKey = this._causticKey, transport = this._transport;
+        const { hasAlpha, hasSceneAlpha, defineCode, pipelineConstantsKeys } = shader;
+        const emitterSource = (mode) => {
+            const code = causticLightCompute(constants, blasLayoutMask, hasDisplacement, mode, '', causticDiagnostics.fullEmissionRandom !== false);
+            return bindless ? bindlessShaderSource(code, this._textureSelection.support.enable) : code;
+        };
+        const lightEmitter = lightTracing ? this._causticLight ??= new WGPUCausticLightPass(this._device) : undefined;
+        const photonEmitter = photonMapping ? this._photonMap?.emission : undefined;
+        const pipelineDiagnostic = {
+            label: 'Ray Trace', entryPoint: 'main', firstFrameRequired: true, status: 'compiling',
+            startedAtMs: 0, concurrentCompilationCount: 1
+        };
+        const variant = {
+            status: 'pending', capabilities: shader.capabilities, structureKey: shader.structureKey,
+            settled: undefined,
+            diagnostics: {
+                status: 'compiling', sourceBytes: 0, sourceLines: 0, pipelineCount: 1,
+                completedPipelineCount: 0, sourceGenerationTimeMs: 0, moduleCreationTimeMs: 0,
+                modules: [], pipelines: [{ ...pipelineDiagnostic }], maximumConcurrentPipelineCount: 1, peakConcurrentPipelineCount: 1
             }
-            this._pipelineError = undefined;
-            const previousPipelineConstantsKeys = wgpuPipelineConstantKeys(this._prevPipelineConstants);
-            const needsCreateShaderModule = !this._rayTracePipelineLayout ||
-                !this._computeShaderModule ||
-                pipelineConstantsKeys.join(',') !==
-                    previousPipelineConstantsKeys.join(',') ||
-                defineCode !== this._prevDefinesCode ||
-                hasAlpha !== this._compiledHasAlpha ||
-                hasSceneAlpha !== this._compiledSceneHasAlpha ||
-                Boolean(constants.USE_ANISOTROPY_DIRECTIONS) !== this._compiledAnisotropyDirections ||
-                Boolean(constants.USE_COAT_NORMAL_FRAMES) !== this._compiledCoatNormals ||
-                this._blasLayoutMask !== this._compiledBlasLayoutMask ||
-                (this._bakePipelineConstants &&
-                    pipelineConstantsKeys.some((key) => constants[key] !== this._prevPipelineConstants[key]));
-            const needsCreatePipeline = needsCreateShaderModule ||
-                pipelineConstantsKeys.some((key) => constants[key] !== this._prevPipelineConstants[key]);
-            compilationStartedAt = needsCreatePipeline
-                ? shaderCompilationNow()
-                : undefined;
-            let sourceGenerationTimeMs = 0;
-            let moduleCreationTimeMs = 0;
-            let sourceBytes = this._shaderCompilationDiagnostics?.sourceBytes ?? 0;
-            let sourceLines = this._shaderCompilationDiagnostics?.sourceLines ?? 0;
-            let sourceFingerprint = this._shaderCompilationDiagnostics?.modules[0]?.sourceFingerprint ?? '';
-            if (needsCreateShaderModule) {
-                const sourceGenerationStartedAt = shaderCompilationNow();
-                let rayTraceShaderCode = wgpuShaderSource(constants, {
-                    hasDisplacement: this._hasDisplacement, hasAlpha, hasSceneAlpha,
+        };
+        const device = this._device, groupIndices = bindless ? [0, 1] : [0, 1, 2];
+        let startedAt = 0;
+        const compile = async () => {
+            startedAt = shaderCompilationNow();
+            // Override values are not part of the WGSL unless they are baked, so a
+            // quality edit can share the module that the driver has already parsed.
+            const moduleKey = JSON.stringify([causticKey, !!bindless, hasAlpha, hasSceneAlpha, hasDisplacement,
+                constants.USE_ANISOTROPY_DIRECTIONS, constants.USE_COAT_NORMAL_FRAMES, blasLayoutMask, defineCode, pipelineConstantsKeys,
+                bake && pipelineConstantsKeys.map((key) => constants[key])]);
+            let source = this._traceModules.get(moduleKey);
+            if (!source) {
+                let code = wgpuShaderSource(constants, {
+                    hasDisplacement,
+                    hasAlpha,
+                    hasSceneAlpha,
+                    ...transport?.features,
+                    lightTracing,
+                    photonMapping,
+                    photonMaxDepth: causticDiagnostics.photonMaxDepth ?? 20,
+                    photonDirectSubset: causticDiagnostics.photonDirectSubset,
+                    debugGroup: causticDiagnostics.debugGroup,
+                    workgroupSize: transport?.workgroupSize ?? WORKGROUP_SIZE,
                     hasAnisotropyDirections: Boolean(constants.USE_ANISOTROPY_DIRECTIONS),
                     hasCoatNormals: Boolean(constants.USE_COAT_NORMAL_FRAMES),
-                    blasLayoutMask: this._blasLayoutMask,
+                    blasLayoutMask,
                     dynamicEnvironment: true
-                }, this._bakePipelineConstants);
-                if (this._bindless)
-                    rayTraceShaderCode = bindlessShaderSource(rayTraceShaderCode, this._textureSelection.support.enable);
-                sourceBytes = rayTraceShaderCode.length;
-                sourceLines = shaderSourceLineCount(rayTraceShaderCode);
-                sourceFingerprint = shaderSourceFingerprint(rayTraceShaderCode);
-                sourceGenerationTimeMs =
-                    shaderCompilationNow() - sourceGenerationStartedAt;
-                const moduleCreationStartedAt = shaderCompilationNow();
-                this._computeShaderModule = this._shaderCache.createShaderModule({
-                    label: 'Ray Trace',
-                    code: rayTraceShaderCode
-                });
-                moduleCreationTimeMs =
-                    shaderCompilationNow() - moduleCreationStartedAt;
-                this._compiledHasAlpha = hasAlpha;
-                this._compiledSceneHasAlpha = hasSceneAlpha;
-                this._compiledAnisotropyDirections = Boolean(constants.USE_ANISOTROPY_DIRECTIONS);
-                this._compiledCoatNormals = Boolean(constants.USE_COAT_NORMAL_FRAMES);
-                this._compiledBlasLayoutMask = this._blasLayoutMask;
+                }, bake);
+                if (bindless)
+                    code = bindlessShaderSource(code, this._textureSelection.support.enable);
+                variant.diagnostics.sourceGenerationTimeMs = shaderCompilationNow() - startedAt;
+                const moduleStartedAt = shaderCompilationNow();
+                source = {
+                    module: this._shaderCache.createShaderModule({ label: 'Ray Trace', code }),
+                    bytes: code.length, lines: shaderSourceLineCount(code), fingerprint: shaderSourceFingerprint(code)
+                };
+                variant.diagnostics.moduleCreationTimeMs = shaderCompilationNow() - moduleStartedAt;
+                this._traceModules.set(moduleKey, source);
+                if (this._traceModules.size > 8)
+                    this._traceModules.delete(this._traceModules.keys().next().value);
             }
-            if (needsCreatePipeline) {
-                if (!this._rayTracePipelineLayout) {
-                    device.pushErrorScope('validation');
-                    let layoutScopeOpen = true;
-                    try {
-                        this._createPipelineLayout();
-                        const layoutError = await device.popErrorScope();
-                        layoutScopeOpen = false;
-                        if (layoutError)
-                            throw layoutError;
-                    }
-                    catch (error) {
-                        const scopedError = layoutScopeOpen
-                            ? await device.popErrorScope().catch(() => null)
-                            : null;
-                        this._rayTracePipelineLayout = undefined;
-                        const detail = joinWebGPUErrors(error, scopedError);
-                        throw new Error(`Unable to create the ray tracing pipeline layout: ${detail}`);
-                    }
-                }
-                // NOTE must before creating pipeline.
-                // Because createComputePipelineAsync is async.
-                // The constants may be changed after the pipeline is created(in setMesh).
-                this._prevPipelineConstants = { ...constants };
-                this._prevDefinesCode = defineCode;
-                this._needsUpdateBindGroups = true;
-                device.pushErrorScope('validation');
-                let pipelineScopeOpen = true;
-                try {
-                    const pipelineConstants = !this._bakePipelineConstants
-                        ? pipelineConstantsKeys.reduce((obj, key) => {
-                            obj[key] = +constants[key];
-                            return obj;
-                        }, {})
-                        : undefined;
-                    const diagnostic = {
-                        label: 'Ray Trace',
-                        entryPoint: 'main',
-                        firstFrameRequired: true,
-                        status: 'compiling'
-                    };
-                    pipelineCompilationStartedAt = shaderCompilationNow();
-                    diagnostic.startedAtMs = 0;
-                    diagnostic.concurrentCompilationCount = 1;
-                    this._shaderCompilationDiagnostics = {
-                        status: 'compiling',
-                        sourceBytes,
-                        sourceLines,
-                        pipelineCount: 1,
-                        completedPipelineCount: 0,
-                        sourceGenerationTimeMs,
-                        moduleCreationTimeMs,
-                        modules: [
-                            {
-                                label: 'Ray Trace',
-                                sourceBytes,
-                                sourceLines,
-                                sourceFingerprint
-                            }
-                        ],
-                        pipelines: [{ ...diagnostic }],
-                        maximumConcurrentPipelineCount: 1,
-                        peakConcurrentPipelineCount: 1
-                    };
-                    let rayTracePipeline;
-                    try {
-                        rayTracePipeline = await this._shaderCache.createComputePipelineAsync({
-                            label: 'Ray Trace',
-                            layout: this._rayTracePipelineLayout,
-                            compute: {
-                                module: this._computeShaderModule,
-                                entryPoint: 'main',
-                                constants: pipelineConstants
-                            }
-                        });
-                        diagnostic.status = 'ready';
-                    }
-                    catch (error) {
-                        diagnostic.status = 'failed';
-                        diagnostic.error = getWebGPUErrorMessage(error);
-                        // Pipeline creation already reports WGSL failures. Pull the much
-                        // heavier module diagnostics only on that failure path so normal
-                        // startup does not schedule a second full-module inspection.
-                        const info = await this._computeShaderModule
-                            .getCompilationInfo()
-                            .catch(() => undefined);
-                        const shaderErrors = (info?.messages ?? [])
-                            .filter((message) => message.type === 'error');
-                        if (shaderErrors.length) {
-                            throw new Error(shaderErrors
-                                .map((message) => `Ray Trace WGSL ${message.lineNum}:${message.linePos} ${message.message}`)
-                                .join('\n'));
-                        }
-                        throw error;
-                    }
-                    finally {
-                        diagnostic.endedAtMs =
-                            shaderCompilationNow() - pipelineCompilationStartedAt;
-                        diagnostic.durationMs = diagnostic.endedAtMs;
-                    }
-                    this._rayTracePipeline = rayTracePipeline;
-                    this._depthCompute = { module: this._computeShaderModule, constants: pipelineConstants };
-                    const pipelineError = await device.popErrorScope();
-                    pipelineScopeOpen = false;
-                    if (pipelineError)
-                        throw pipelineError;
-                    const compilationCompletedAt = shaderCompilationNow();
-                    this._shaderCompilationDiagnostics = {
-                        ...this._shaderCompilationDiagnostics,
-                        status: 'ready',
-                        completedPipelineCount: 1,
-                        pipelines: [{ ...diagnostic }],
-                        pipelineCompilationTimeMs: compilationCompletedAt - pipelineCompilationStartedAt,
-                        totalTimeMs: compilationCompletedAt - compilationStartedAt
-                    };
-                }
-                catch (error) {
-                    const scopedError = pipelineScopeOpen
-                        ? await device.popErrorScope().catch(() => null)
-                        : null;
-                    const detail = joinWebGPUErrors(error, scopedError);
-                    if (!this._bakePipelineConstants &&
-                        isWebGPUPipelineSpecializationFailure(error, scopedError)) {
-                        const failedAt = shaderCompilationNow();
-                        if (this._shaderCompilationDiagnostics?.status === 'compiling') {
-                            this._shaderCompilationDiagnostics = {
-                                ...this._shaderCompilationDiagnostics,
-                                status: 'failed',
-                                pipelineCompilationTimeMs: pipelineCompilationStartedAt == null
-                                    ? undefined
-                                    : failedAt - pipelineCompilationStartedAt,
-                                totalTimeMs: compilationStartedAt == null
-                                    ? undefined
-                                    : failedAt - compilationStartedAt,
-                                error: detail
-                            };
-                        }
-                        // WebKit can accept a large WGSL module but fail while translating
-                        // its specialization-constant variant to Metal. Baking the values
-                        // into WGSL lets its front end eliminate disabled feature branches
-                        // before creating the Metal library.
-                        this._bakePipelineConstants = true;
-                        this._rayTracePipeline = undefined;
-                        this._rayTraceBindGroups = undefined;
-                        this._computeShaderModule = undefined;
-                        this._prevPipelineConstants = {};
-                        console.warn('WebGPU pipeline specialization failed; retrying with constants baked into WGSL.');
-                        return;
-                    }
-                    throw new Error(detail);
+            Object.assign(variant.diagnostics, {
+                sourceBytes: source.bytes, sourceLines: source.lines,
+                modules: [{ label: 'Ray Trace', sourceBytes: source.bytes, sourceLines: source.lines, sourceFingerprint: source.fingerprint }]
+            });
+            const { module } = source;
+            const layout = this._createPipelineLayout(!!bindless, photonMapping);
+            const pipelineConstants = !bake
+                ? pipelineConstantsKeys.reduce((obj, key) => {
+                    obj[key] = +constants[key];
+                    return obj;
+                }, {})
+                : undefined;
+            const lightSource = lightEmitter && emitterSource('lightTracing');
+            const photonSource = photonEmitter && emitterSource('photonMapping');
+            // Scopes capture all device errors while open, so one must never span an
+            // await: frames presented meanwhile would be blamed on this pipeline.
+            device.pushErrorScope('validation');
+            const request = this._shaderCache.createComputePipelineAsync({
+                label: 'Ray Trace', layout,
+                compute: { module, entryPoint: 'main', constants: pipelineConstants }
+            });
+            const scope = device.popErrorScope().catch(() => null);
+            let pipeline;
+            try {
+                pipeline = await request;
+                const scopedError = await scope;
+                if (scopedError)
+                    throw scopedError;
+            }
+            catch (error) {
+                const scopedError = await scope;
+                // Pipeline creation already reports WGSL failures. Pull the much
+                // heavier module diagnostics only on that failure path so normal
+                // startup does not schedule a second full-module inspection.
+                const info = await module.getCompilationInfo().catch(() => undefined);
+                const shaderErrors = (info?.messages ?? []).filter((message) => message.type === 'error');
+                if (shaderErrors.length) {
+                    throw new Error(shaderErrors
+                        .map((message) => `Ray Trace WGSL ${message.lineNum}:${message.linePos} ${message.message}`)
+                        .join('\n'));
                 }
+                if (isWebGPUPipelineSpecializationFailure(error, scopedError))
+                    throw error;
+                throw new Error(joinWebGPUErrors(error, scopedError));
             }
-            // Compilation can complete after Engine disposal/device loss has released
-            // the material table and its textures. Never bind that retired generation.
+            const groups = lightEmitter || photonEmitter ? groupIndices.map((i) => pipeline.getBindGroupLayout(i)) : [];
+            const [light, photon] = await Promise.all([
+                lightEmitter?.prepare(lightSource, groups, !!bindless),
+                photonEmitter?.prepare(photonSource, groups, !!bindless)
+            ]);
+            Object.assign(variant, { pipeline, lightEmitter: light, photonEmitter: photon,
+                depthCompute: { module, constants: pipelineConstants } });
+        };
+        const finishDiagnostics = (status, error) => {
+            const totalTimeMs = shaderCompilationNow() - startedAt;
+            Object.assign(variant.diagnostics, {
+                status, completedPipelineCount: status === 'ready' ? 1 : 0, error,
+                pipelines: [{ ...pipelineDiagnostic, status, error, endedAtMs: totalTimeMs, durationMs: totalTimeMs }],
+                pipelineCompilationTimeMs: totalTimeMs, totalTimeMs
+            });
+        };
+        const run = () => compile().then(() => {
+            variant.status = 'ready';
+            finishDiagnostics('ready');
+        }, (error) => {
+            finishDiagnostics('failed', getWebGPUErrorMessage(error));
             if (this._disposed)
                 return;
-            // TODO rebind when lights, materials, bvh changed.
-            if (this._needsUpdateBindGroups) {
-                this._needsUpdateBindGroups = false;
-                this._updateBindGroups();
+            if (!bake && isWebGPUPipelineSpecializationFailure(error)) {
+                // WebKit can accept a large WGSL module but fail while translating
+                // its specialization-constant variant to Metal. Baking the values
+                // into WGSL lets its front end eliminate disabled feature branches
+                // before creating the Metal library. The next request has a new
+                // signature, so this one stays pending until it is replaced.
+                this._bakePipelineConstants = true;
+                this._traceVariants.delete(signature);
+                console.warn('WebGPU pipeline specialization failed; retrying with constants baked into WGSL.');
+                return;
             }
-            this._retainedShaderCapabilities = capabilities;
-            this._retainedShaderStructure = structureKey;
-            this._shaderCapabilities.remember(structureKey, capabilities);
-            this._prevPipelineInputs = pipelineInputs;
-            this._failedPipelineSignature = undefined;
-        }
-        catch (error) {
-            if (this._disposed)
+            // Nobody needs an obsolete result, and a later request should try again.
+            if (this._requestedVariant !== variant) {
+                this._traceVariants.delete(signature);
+                variant.status = 'failed';
                 return;
-            this._pipelineError = error;
-            const failedAt = shaderCompilationNow();
-            if (this._shaderCompilationDiagnostics?.status === 'compiling') {
-                this._shaderCompilationDiagnostics = {
-                    ...this._shaderCompilationDiagnostics,
-                    status: 'failed',
-                    pipelineCompilationTimeMs: pipelineCompilationStartedAt == null
-                        ? undefined
-                        : failedAt - pipelineCompilationStartedAt,
-                    totalTimeMs: compilationStartedAt == null
-                        ? undefined
-                        : failedAt - compilationStartedAt,
-                    error: getWebGPUErrorMessage(error)
-                };
             }
-            this._failedPipelineSignature = attemptedPipelineSignature;
-            // Do not allow the render loop to submit the previous/partial state.
-            // The failed signature prevents retrying the same shader every frame;
-            // changing a pipeline-affecting setting permits a new attempt.
-            this._rayTracePipeline = undefined;
-            this._rayTraceBindGroups = undefined;
-            this._prevPipelineConstants = {};
-            this._needsUpdateBindGroups = true;
+            variant.status = 'failed';
+            variant.error = error;
             console.error('Failed to update WebGPU ray tracing pipeline.', error);
+        });
+        variant.settled = new Promise((resolve) => {
+            this._queuedCompiles.push({ variant, signature, run, release: resolve });
+        });
+        this._traceVariants.set(signature, variant);
+        if (this._queuedCompiles.length > MAX_QUEUED_COMPILES) {
+            // A dropped variant stays pending, because a render that still wants it
+            // replaces it with a new request on its next frame.
+            const obsolete = this._queuedCompiles.shift();
+            if (this._traceVariants.get(obsolete.signature) === obsolete.variant)
+                this._traceVariants.delete(obsolete.signature);
+            obsolete.release();
+        }
+        for (const [key, retained] of this._traceVariants) {
+            if (this._traceVariants.size <= MAX_TRACE_VARIANTS)
+                break;
+            if (retained.status !== 'pending' && retained !== this._activeVariant)
+                this._traceVariants.delete(key);
+        }
+        this._pumpCompiles();
+        return variant;
+    }
+    /** Runs the most recently requested variants first: a dragged slider's last value is the one in use. */
+    _pumpCompiles() {
+        while (this._activeCompiles < MAX_CONCURRENT_COMPILES && this._queuedCompiles.length) {
+            const job = this._queuedCompiles.pop();
+            this._activeCompiles++;
+            void job.run().finally(() => {
+                this._activeCompiles--;
+                job.release();
+                if (!this._disposed)
+                    this._pumpCompiles();
+            });
         }
-        finally {
-            this._isCompilingShader = false;
-        }
+    }
+    _requestQueuedCompile(variant) {
+        const index = this._queuedCompiles.findIndex((job) => job.variant === variant);
+        if (index >= 0)
+            this._queuedCompiles.push(...this._queuedCompiles.splice(index, 1));
     }
     _prepareAovPipelines(kinds) {
         const trace = this._rayTracePipeline;
@@ -890,7 +979,7 @@ class WGPURayTracePass {
             void Promise.all([
                 this._shaderCache.createComputePipelineAsync({ label: 'AOV accumulation', layout, compute: { ...compute, entryPoint: 'aovTrace' } }),
                 this._shaderCache.createComputePipelineAsync({ label: 'AOV center', layout, compute: { ...compute, entryPoint: 'aovTraceCenter' } })
-            ]).then(([accumulation, center]) => { pending.accumulation = accumulation; pending.center = center; }, error => { pending.error = error; });
+            ]).then(([accumulation, center]) => { pending.accumulation = accumulation; pending.center = center; }, error => { pending.error = error; this._aovPipelinesFailed = true; });
         }
         if (pipelines.error)
             throw pipelines.error;
@@ -959,7 +1048,7 @@ class WGPURayTracePass {
         const tracePipeline = this._rayTracePipeline;
         const groups = this._rayTraceBindGroups;
         const textures = this._bindless, textureRevision = textures?.revision;
-        if (!tracePipeline || !groups || !this._depthCompute || this._isCompilingShader)
+        if (!tracePipeline || !groups || !this._depthCompute || this.isCompilingShader())
             return;
         const packed = packDepthSampleArea(area, aspect ?? this._width / this._height);
         if (this._depthTracePipeline !== tracePipeline || !this._depthPipeline) {
@@ -1023,15 +1112,17 @@ class WGPURayTracePass {
             params.destroy();
         }
     }
+    /** Whether the latest request waits on GPU work that will settle on its own. */
     isCompilingShader() {
-        return this._isCompilingShader;
+        return !!this._awaitingRetirement || this._requestedVariant?.status === 'pending';
     }
     isPipelineReady() {
         return ((!!this._rayTracePipeline) &&
             !!this._rayTraceBindGroups);
     }
+    /** Failure of the latest request. A failed variant does not affect other renders. */
     getPipelineError() {
-        return this._pipelineError;
+        return this._resourceError ?? this._requestedVariant?.error;
     }
     _updateBindGroups() {
         const { _device } = this;
@@ -1054,14 +1145,18 @@ class WGPURayTracePass {
             }
         }));
         const textureEntries = [
-            ...(this._bindless ? [] : [{
-                    binding: 0,
-                    resource: this._mapsSampler
-                },
-                {
-                    binding: 1,
-                    resource: this._maps.createView()
-                }]),
+            ...(this._bindless
+                ? []
+                : [
+                    {
+                        binding: 0,
+                        resource: this._mapsSampler
+                    },
+                    {
+                        binding: 1,
+                        resource: this._maps.createView()
+                    }
+                ]),
             {
                 binding: 3,
                 resource: {
@@ -1071,6 +1166,12 @@ class WGPURayTracePass {
             { binding: 4, resource: this._envTex.createView() },
             { binding: 5, resource: this._envDistributionTex.createView() },
             { binding: 6, resource: this._backgroundTex.createView() },
+            ...(this._photonMapping
+                ? [
+                    { binding: 11, resource: this._photonMap.get(this._activeTarget).data.createView() },
+                    { binding: 12, resource: this._photonMap.get(this._activeTarget).headers.createView() }
+                ]
+                : []),
             { binding: 8, resource: this._lightSamplingTexture.createView() },
             { binding: 9, resource: this._openPbrEnergyLut.createView() },
             {
@@ -1078,11 +1179,18 @@ class WGPURayTracePass {
                 resource: this._adaptiveSamplingTexture.createView()
             }
         ];
-        const bufferBindGroup = _device.createBindGroup({ layout: bindGroupPipeline.getBindGroupLayout(0),
-            entries: this._bindless ? bufferEntries.concat(textureEntries.map(e => ({ ...e, binding: e.binding + 4 }))) : bufferEntries });
-        const texturesBindGroup = this._bindless ? undefined : _device.createBindGroup({
-            layout: bindGroupPipeline.getBindGroupLayout(1), entries: textureEntries
+        const bufferBindGroup = _device.createBindGroup({
+            layout: bindGroupPipeline.getBindGroupLayout(0),
+            entries: this._bindless
+                ? bufferEntries.concat(textureEntries.map((e) => ({ ...e, binding: e.binding + 4 })))
+                : bufferEntries
         });
+        const texturesBindGroup = this._bindless
+            ? undefined
+            : _device.createBindGroup({
+                layout: bindGroupPipeline.getBindGroupLayout(1),
+                entries: textureEntries
+            });
         const uniformBindGroup = _device.createBindGroup({
             layout: bindGroupPipeline.getBindGroupLayout(this._bindless ? 1 : 2),
             entries: Object.keys(this._uniforms).map((key, i) => ({
@@ -1092,19 +1200,36 @@ class WGPURayTracePass {
                 }
             }))
         });
+        if (this._photonMapping) {
+            // Explicit layouts still track unused textures. Bind a placeholder while
+            // emission writes the real packed map through its storage view.
+            const emissionEntries = textureEntries.map((entry) => entry.binding === 11 || entry.binding === 12
+                ? { ...entry, resource: this._photonMap.placeholder.createView() }
+                : entry);
+            const sceneGroup = _device.createBindGroup({
+                layout: bindGroupPipeline.getBindGroupLayout(this._bindless ? 0 : 1),
+                entries: this._bindless
+                    ? bufferEntries.concat(emissionEntries.map((e) => ({ ...e, binding: e.binding + 4 })))
+                    : emissionEntries
+            });
+            this._photonEmissionGroups = this._bindless
+                ? [sceneGroup, uniformBindGroup]
+                : [bufferBindGroup, sceneGroup, uniformBindGroup];
+        }
         const target = this._targetOutputs.get(this._activeTarget);
-        const outputBindGroup = target.pipeline === bindGroupPipeline && target.bindGroup || _device.createBindGroup({
-            layout: bindGroupPipeline.getBindGroupLayout(this._bindless ? 2 : 3),
-            entries: [
-                this._outColorBuffer,
-                this._outNormalBuffer,
-                this._outAlbedoBuffer,
-                this._outShadowCatcherBuffer
-            ].map((buffer, i) => ({
-                binding: i,
-                resource: { buffer }
-            }))
-        });
+        const outputBindGroup = (target.pipeline === bindGroupPipeline && target.bindGroup) ||
+            _device.createBindGroup({
+                layout: bindGroupPipeline.getBindGroupLayout(this._bindless ? 2 : 3),
+                entries: [
+                    this._outColorBuffer,
+                    this._outNormalBuffer,
+                    this._outAlbedoBuffer,
+                    this._outShadowCatcherBuffer
+                ].map((buffer, i) => ({
+                    binding: i,
+                    resource: { buffer }
+                }))
+            });
         target.bindGroup = outputBindGroup;
         target.pipeline = bindGroupPipeline;
         this._rayTraceBindGroups = [
@@ -1131,6 +1256,36 @@ class WGPURayTracePass {
             encoder.clearBuffer(this._outAlbedoBuffer);
             encoder.clearBuffer(this._outShadowCatcherBuffer);
         }
+        const offset = this._rtUniform.views.scaleOffset;
+        const causticBatch = this._lightTracing && offset[2] === tiles[0] - 1 && offset[3] === tiles[1] - 1;
+        const photonBatch = this._photonMapping && offset[2] === 0 && offset[3] === 0;
+        if (photonBatch && this._photonMap) {
+            const requested = this._causticSettings?.photonMapping, initial = typeof requested === 'object' ? requested.initialRadius : undefined;
+            const radius = Number.isFinite(initial) && initial > 0 ? initial : Math.max((causticDiagnostics.photonPerCasterRadius
+                ? causticCasterSpheres(this._meshes).reduce((maximum, s) => Math.max(maximum, s[3]), 0)
+                : this._causticBounds[3]) * 0.03, 1e-4);
+            const batch = Math.max(1, this._rtUniform.views.sampleCount[0] - this._rtUniform.views.sampleSequenceOffset[0] + 1);
+            const photonViewProjection = mat4.create();
+            mat4.invert(photonViewProjection, this._viewProjInv);
+            this._photonMap.encode(encoder, this._photonEmissionGroups, this._activeTarget, photonRadius(radius, causticDiagnostics.photonDebugBatch ?? batch, causticDiagnostics.photonAlpha ?? 2 / 3, 
+            // Allocation limits may reduce the requested count.
+            this._photonMap.get(this._activeTarget).count, causticDiagnostics.photonRadiusScaling), {
+                querySet: timing?.querySet,
+                resourceTable: this._bindless?.table,
+                orthographic: !this._causticPerspective,
+                progressiveBatch: batch,
+                width: this._width,
+                height: this._height,
+                clear,
+                run: true,
+                photons: 1,
+                batch: Math.floor(this._rtUniform.views.sampleCount[0]),
+                ...this._transport?.uniform,
+                viewProjection: photonViewProjection,
+                casterSphere: this._causticBounds,
+                cameraScale: this._causticCameraScale
+            });
+        }
         const descriptor = {};
         const querySet = timing?.querySet;
         if (querySet) {
@@ -1150,8 +1305,32 @@ class WGPURayTracePass {
         this._rayTraceBindGroups.forEach((bindGroup, idx) => {
             pass.setBindGroup(idx, bindGroup);
         });
-        pass.dispatchWorkgroups(Math.ceil(dispatchWidth / WORKGROUP_SIZE), Math.ceil(dispatchHeight / WORKGROUP_SIZE), 1);
+        researchTransport()?.capture(this);
+        pass.dispatchWorkgroups(Math.ceil(dispatchWidth / (this._transport?.workgroupSize ?? WORKGROUP_SIZE)), Math.ceil(dispatchHeight / (this._transport?.workgroupSize ?? WORKGROUP_SIZE)), 1);
         pass.end();
+        if (this._lightTracing && this._causticLight) {
+            const viewProjection = mat4.create();
+            mat4.invert(viewProjection, this._viewProjInv);
+            const requested = this._causticSettings?.lightTracing;
+            const count = typeof requested === 'object' ? requested.photonsPerSample : undefined;
+            const photons = Math.min(this._device.limits.maxComputeWorkgroupsPerDimension * 64, Math.max(1, Math.round(Number.isFinite(count) ? count : (this._width * this._height) / 4)));
+            this._causticLight.encode(encoder, this._rayTraceBindGroups.slice(0, this._bindless ? 2 : 3), this._activeTarget, {
+                querySet: causticBatch ? querySet : undefined,
+                width: this._width,
+                height: this._height,
+                clear,
+                run: !!causticBatch,
+                photons,
+                batch: Math.floor(this._rtUniform.views.sampleCount[0]),
+                ...this._transport?.uniform,
+                resourceTable: this._bindless?.table,
+                orthographic: !this._causticPerspective,
+                viewProjection,
+                casterSphere: this._causticBounds,
+                cameraScale: this._causticCameraScale
+            });
+        }
+        return (causticBatch ? 1 : 0) | (photonBatch ? 2 : 0);
     }
     async getDebugBVHData() {
         if (!this._debugBVHBuffer) {
@@ -1174,7 +1353,7 @@ class WGPURayTracePass {
                     scale: atlas?.scale ?? 1, metadataBytes: 0, resourceTableCapacity: 0, retiredBytes: 0
                 })
             },
-            shaderCompilation: this._shaderCompilationDiagnostics,
+            shaderCompilation: this._requestedVariant?.diagnostics,
             lightSampling: {
                 emissiveTriangles: this._emissiveTriangles.length,
                 activeChoices: this._rtUniform.views.lightChoiceCount[0],
@@ -1194,15 +1373,6 @@ class WGPURayTracePass {
         if (next === this._alphaBlendStrategy)
             return false;
         this._alphaBlendStrategy = next;
-        if (this._constants.HAS_ALPHA_BLEND) {
-            this._computeShaderModule = undefined;
-            this._rayTracePipeline = undefined;
-            this._rayTracePipelineLayout = undefined;
-            this._rayTraceBindGroups = undefined;
-            this._prevPipelineConstants = {};
-            this._failedPipelineSignature = undefined;
-            this._needsUpdateBindGroups = true;
-        }
         return true;
     }
     hasDepthOfField() {
@@ -1266,8 +1436,28 @@ class WGPURayTracePass {
         this._device.queue.writeTexture({ texture: this._adaptiveSamplingTexture }, data, { bytesPerRow: width * Float32Array.BYTES_PER_ELEMENT }, [width, height]);
     }
     setQuality(options) {
+        WGPURayTracePass.prototype._setCaustics.call(this, options.caustics);
         writeTraceQuality(this._rtUniform.views, options);
     }
+    _setCaustics(settings) {
+        this._causticSettings = settings;
+        const transport = researchTransport()?.configure(this, 'webgpu');
+        if (!!transport?.enabled !== !!this._transport?.enabled)
+            this._needsUpdateLightSamplingData = true;
+        this._transport = transport;
+        const hasCaster = !!(settings?.lightTracing || settings?.photonMapping) &&
+            this._meshes.some((mesh) => mesh.materials.some(isCausticSpecular));
+        const photonSupported = !(settings?.lightTracing || settings?.photonMapping) ||
+            !hasCaster ||
+            !hasStochasticCausticCaster(this._meshes);
+        this._lightTracing = !!settings?.lightTracing && hasCaster && photonSupported;
+        const photonMapping = !!settings?.photonMapping && hasCaster && photonSupported;
+        this._photonMapping = photonMapping;
+        this._causticKey =
+            this._transport?.enabled || this._lightTracing || this._photonMapping
+                ? `${this._lightTracing}/${this._photonMapping}/${causticDiagnostics.fullEmissionRandom !== false}/${causticDiagnostics.photonMaxDepth ?? 20}/${causticDiagnostics.debugGroup}/${causticDiagnostics.photonDirectSubset !== false}/${this._transport?.key ?? ''}`
+                : '';
+    }
     _setEnvMap(envImage) {
         const device = this._device;
         // Always create env tex
@@ -1621,14 +1811,19 @@ class WGPURayTracePass {
         this._needsUpdateBindGroups ||= resized;
     }
     _updateLightSamplingData() {
-        this._constants.LIGHT_CAPABILITIES = lightShaderCapabilities(this._analyticLights.map(light => light.type), this._emissiveTriangles.length);
-        const lighting = prepareSceneLightSampling(this._analyticLights, this._emissiveTriangles, this._envImageSource && 'sky' in this._envImageSource ? proceduralEnvironmentPower(this._envImageSource) : estimateEnvironmentPower(this._envImageSource), this._device.limits.maxTextureDimension2D, this._lightChoices, this._lightSamplingScratch, this._shadowCatcherLightChoices);
+        this._constants.LIGHT_CAPABILITIES = lightShaderCapabilities(this._analyticLights.map((light) => light.type), this._emissiveTriangles.length);
+        const lighting = prepareSceneLightSampling(this._analyticLights, this._emissiveTriangles, this._envImageSource && 'sky' in this._envImageSource
+            ? proceduralEnvironmentPower(this._envImageSource)
+            : estimateEnvironmentPower(this._envImageSource), this._device.limits.maxTextureDimension2D, this._lightChoices, this._lightSamplingScratch, this._shadowCatcherLightChoices);
+        researchTransport()?.prepare(this, 'webgpu', lighting);
         this._analyticLightSelectionPmfs = lighting.analyticPmfs;
         this._iesProfileTexelOffsets = lighting.profiles.offsets;
         this._lightDomainDiagnostics = lighting.domains;
         const { lightWidth: width, lightHeight: height, lightData: textureData } = lighting;
         writeTraceLighting(this._rtUniform.views, lighting);
-        const resized = !this._lightSamplingTexture || width !== this._lightSamplingTextureSize[0] || height !== this._lightSamplingTextureSize[1];
+        const resized = !this._lightSamplingTexture ||
+            width !== this._lightSamplingTextureSize[0] ||
+            height !== this._lightSamplingTextureSize[1];
         if (!this._lightSamplingTexture ||
             width !== this._lightSamplingTextureSize[0] ||
             height !== this._lightSamplingTextureSize[1]) {
@@ -1770,11 +1965,7 @@ class WGPURayTracePass {
         }
         this._hasShadowCatcher = materials.some((m) => m.shadowCatcher);
         const hasDisplacement = materialData.getDisplacementMaps().length > 0;
-        if (hasDisplacement !== this._hasDisplacement) {
-            this._hasDisplacement = hasDisplacement;
-            // Needs to recreate pipeline layout
-            this._rayTracePipelineLayout = undefined;
-        }
+        this._hasDisplacement = hasDisplacement;
         Object.assign(this._constants, wgpuMaterialConstants(materials, materialData, mergedGeometry, this._bevelSamples, Number(this._constants.NUM_MAPS ?? 0)));
         // Runtime storage metadata has no texture-count specialization.
         if (this._bindless)
@@ -1945,8 +2136,6 @@ class WGPURayTracePass {
             this._retiredBindless.add(retired);
             void this._device.queue.onSubmittedWorkDone().catch(() => { }).then(() => { retired.dispose(); this._retiredBindless.delete(retired); });
             this._bindless = undefined;
-            this._computeShaderModule = undefined;
-            this._rayTracePipelineLayout = undefined;
         }
         return new MaterialTable(...args);
     }
@@ -2058,6 +2247,10 @@ class WGPURayTracePass {
     }
     // TODO reuse the code of RayTraceNode
     setCamera(camera) {
+        this._causticPerspective = camera.projection === 'perspective';
+        const projection = camera.getProjectionMatrix(this._targetAspect);
+        this._causticCameraScale = Math.abs(projection[0] * projection[5]) / 4;
+        this._setCaustics(this._causticSettings);
         const viewProjectionInvMat = this._viewProjInv;
         this._apertureRadius = cameraApertureRadius(camera);
         this._focusDistance = camera.focusDistance;
@@ -2147,12 +2340,14 @@ class WGPURayTracePass {
         this._envDistribution?.dispose();
         this._skyBaker?.dispose();
         this._bindless?.dispose();
-        this._retiredBindless.forEach(textures => textures.dispose());
+        this._retiredBindless.forEach((textures) => textures.dispose());
         this._retiredBindless.clear();
+        this._causticLight?.dispose();
+        this._photonMap?.dispose();
         this._shaderCache.clear();
         this._shaderCapabilities.clear();
         const buffers = new Set([
-            ...Array.from(this._targetOutputs.values()).flatMap(target => target.buffers),
+            ...Array.from(this._targetOutputs.values()).flatMap((target) => target.buffers),
             this._mapInfoUniform,
             this._attrBuffers,
             this._materialsBuffer,
@@ -2172,6 +2367,9 @@ class WGPURayTracePass {
             this._adaptiveSamplingTexture
         ]);
         textures.forEach((texture) => texture?.destroy());
+        for (const job of this._queuedCompiles.splice(0))
+            job.release();
+        this._traceVariants.clear();
         this._rayTracePipeline = undefined;
         this._rayTraceBindGroups = undefined;
     }