@meimu/mutracer 0.2.0 → 0.3.1

package/lib/renderer/WGPURayTracePass.js

@@ -1,9 +1,19 @@
+import { resolveSurfaceHit } from './surfaceHit.js';
+import { compactVertexLayout, packCompactVertices, packTriangleMaterials } from './compactVertices.js';
+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';
+import { aovMask, AOV_ACCUMULATED_MASK, AOV_REFLECTANCE_MASK, COMPACT_AOV_KINDS } from './aov.js';
 import { proceduralEnvironmentPower } from './proceduralEnvironmentPower.js';
 import { WGPUSkyBaker } from './WGPUSkyBaker.js';
-import { initialSceneConstants, sceneAttributeLayout, sceneTraversalConstants, prepareSceneLightSampling, writeTraceLighting, packSceneAnalyticLights, writeTraceQuality, traceSampling, writeTraceSampling } from './sceneAssembly.js';
+import { initialSceneConstants, sceneTraversalConstants, prepareSceneLightSampling, writeTraceLighting, packSceneAnalyticLights, writeTraceQuality, traceSampling, writeTraceSampling } from './sceneAssembly.js';
 import { rayTraceBindGroupLayouts } from './sceneLayoutSchema.js';
 import { WGPUBindlessMaterialData } from './WGPUBindlessMaterialData.js';
 import { WGPUBindlessTextures } from './WGPUBindlessTextures.js';
@@ -14,7 +24,7 @@ import { wgpuShaderSource, wgpuPipelineConstantKeys, WGPU_SHADER_DEFINE_KEYS } f
 import { makeRayTraceUniform, WGPU_SCENE_BUFFER_MIN_BYTES } from './wgpuSceneUniform.js';
 import { constants } from './webgl.js';
 import { MATERIAL_FLOAT_COUNT } from './materialLayoutSchema.js';
-import { normalizeBounces } from './pathLimits.js';
+import { normalizeBounces, MAX_PATH_EVENTS_WGPU } from './pathLimits.js';
 import { updateMeshInstanceColors } from './prepareMeshBVH.js';
 import { updateTLASInstanceColors } from './bvhAccel.js';
 import { getMaterialHashKey } from '../scene/openPbrSchema.js';
@@ -27,8 +37,7 @@ import { packCameraUniform } from './cameraUniform.js';
 import { SHADOW_CATCHER_ACCUMULATION_BYTES } from './wgsl/chunks/shadowCatcherAccumulation.wgsl.js';
 import { DEPTH_SAMPLE_COUNT, packDepthSampleArea, unpackDepthSamples } from './depthQuery.js';
 import { MeshMembershipCache } from './meshMembership.js';
-import { mergeRefitRanges } from './bvhAccel.js';
-import { updatePreparedGeometries, canUpdateGeometries, geometryTopologyChanged, packVertexAttributes } from './geometryUpdates.js';
+import { updatePreparedGeometries, canUpdateGeometries, geometryTopologyChanged, } from './geometryUpdates.js';
 import { SceneEnvironmentCache, RectLightTextureTracker } from './sceneLightChanges.js';
 import { MaterialChangeTracker, materialIsEmissive } from './materialChanges.js';
 import { WGPUEnvMapDistribution } from './WGPUEnvMapDistribution.js';
@@ -43,10 +52,10 @@ import { generateBackgroundMapFromSceneBackground, environmentRotation, backgrou
 import { WORKGROUP_SIZE } from './wgsl/rayTrace.compute.js';
 import { envMapDistribution, environmentMapSourcesMatch } from './envMapDistribution.js';
 import { updateMeshInstances, updateMeshInstanceTransforms } from './prepareMeshBVH.js';
-import { buildTLAS, concatBLASBuffers, getTraversalStackSizes, refitBLAS, refitTLAS } from './bvhAccel.js';
+import { buildWebTLAS, 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 +87,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 +126,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 +170,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 +180,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 +243,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;
@@ -238,23 +272,26 @@ class WGPURayTracePass {
     _clamping;
     _transmissiveAlphaMin = 1;
     _viewProjInv = mat4.create();
+    _projectionInv = mat4.create();
     _cameraWorld = mat4.create();
     _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;
+    _bvhCPU;
+    _bvhDataBytes = 0;
     // Fold scene invariants before backend inlining; runtime edits use uniforms.
     _bakePipelineConstants = true;
-    _failedPipelineSignature;
     constructor(device, _textureSelection = { requested: 'atlas' }) {
         this._textureSelection = _textureSelection;
         this._device = device;
@@ -262,7 +299,7 @@ class WGPURayTracePass {
         if (_textureSelection.support)
             this._bindless = new WGPUBindlessTextures(device);
         this._uniforms = {
-            cameraUniform: this._uniformBuffer(36 * 4),
+            cameraUniform: this._uniformBuffer(52 * 4),
             rtUniform: this._uniformBuffer(this._rtUniform.buffer.byteLength),
             analyticLights: this._uniformBuffer(FIXED_LIGHT_COUNT * PIXELS_PER_LIGHT * 4 * 4)
         };
@@ -298,8 +335,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,16 +537,33 @@ 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;
         const size = Math.max(data.byteLength, minSize);
+        const limit = Math.min(device.limits?.maxBufferSize ?? Infinity, device.limits?.maxStorageBufferBindingSize ?? Infinity);
+        if (size > limit)
+            throw new RangeError(`${label} buffer requires ${size} bytes; device storage buffer limit is ${limit} bytes.`);
         if (gpuBuffer == null || gpuBuffer.size < size) {
             this._needsUpdateBindGroups = true;
             if (gpuBuffer) {
@@ -514,10 +574,22 @@ class WGPURayTracePass {
                 size,
                 usage: GPUBufferUsage.STORAGE |
                     GPUBufferUsage.COPY_DST |
-                    GPUBufferUsage.COPY_SRC
+                    GPUBufferUsage.COPY_SRC,
+                // Chromium's mapped-creation IPC payload is limited to a signed 32-bit
+                // size even when the adapter supports larger storage buffers.
+                mappedAtCreation: size < 0x80000000
             });
+            if (size < 0x80000000) {
+                new Uint8Array(gpuBuffer.getMappedRange()).set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+                gpuBuffer.unmap();
+                return gpuBuffer;
+            }
+        }
+        // Bound each staging allocation/IPC payload for large or reused buffers.
+        const chunkBytes = 64 * 1024 * 1024;
+        for (let offset = 0; offset < data.byteLength; offset += chunkBytes) {
+            this._device.queue.writeBuffer(gpuBuffer, offset, data.buffer, data.byteOffset + offset, Math.min(chunkBytes, data.byteLength - offset));
         }
-        this._device.queue.writeBuffer(gpuBuffer, 0, data.buffer);
         return gpuBuffer;
     }
     _uniformBuffer(size) {
@@ -527,22 +599,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 +653,51 @@ 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,
+                Boolean(this._constants.SPECTRAL) && this._shareSpectralPrefix,
+                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 = {
+                shareSpectralPrefix: Boolean(constants.SPECTRAL) && this._shareSpectralPrefix,
                 hasDisplacement: this._hasDisplacement,
+                caustics: this._causticKey,
+                bindless: !!this._bindless,
                 hasAlpha,
                 hasSceneAlpha,
                 hasAnisotropyDirections: Boolean(constants.USE_ANISOTROPY_DIRECTIONS),
@@ -588,10 +706,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,280 +718,279 @@ 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 shareSpectralPrefix = Boolean(constants.SPECTRAL) && this._shareSpectralPrefix;
+        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, true, true);
+            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, shareSpectralPrefix, Boolean(constants.SPECTRAL), 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, {
+                    maxPathEvents: MAX_PATH_EVENTS_WGPU,
+                    hasDisplacement,
+                    channelIndependentRis: Boolean(constants.SPECTRAL),
+                    shareSpectralPrefix,
+                    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,
-                    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;
+                    blasLayoutMask,
+                    cameraProjectionInverse: true,
+                    perInstanceBounds: true,
+                    compactVertices: true,
+                    dynamicEnvironment: true,
+                    displayAovStorage: true
+                }, 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);
-        }
-        finally {
-            this._isCompilingShader = false;
+        });
+        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();
+            });
         }
     }
-    _prepareAovPipelines(kinds) {
+    _requestQueuedCompile(variant) {
+        const index = this._queuedCompiles.findIndex((job) => job.variant === variant);
+        if (index >= 0)
+            this._queuedCompiles.push(...this._queuedCompiles.splice(index, 1));
+    }
+    _prepareAovPipelines(kinds, compact = false) {
         const trace = this._rayTracePipeline;
         if (!trace || !this._depthCompute)
             return;
-        const reflectance = (aovMask(kinds) & 24) !== 0;
+        const reflectance = (aovMask(kinds) & AOV_REFLECTANCE_MASK) !== 0;
         let variants = this._aovPipelines.get(trace);
         if (!variants) {
             variants = new Map();
             this._aovPipelines.set(trace, variants);
         }
-        let pipelines = variants.get(reflectance);
+        const key = Number(reflectance) + Number(compact) * 2;
+        let pipelines = variants.get(key);
         if (!pipelines) {
             pipelines = {};
-            variants.set(reflectance, pipelines);
+            variants.set(key, pipelines);
             const pending = pipelines;
             const textures = this._bindless, groupIndex = textures ? 2 : 3;
             const output = this._device.createBindGroupLayout({ entries: [
@@ -884,42 +1002,45 @@ class WGPURayTracePass {
                 ] });
             const descriptor = { bindGroupLayouts: Array.from({ length: groupIndex }, (_, i) => trace.getBindGroupLayout(i)).concat(output) };
             const layout = this._device.createPipelineLayout(textures ? resourceTableLayout(descriptor) : descriptor);
-            const compute = { ...this._depthCompute, constants: { ...this._depthCompute.constants, DEPTH_QUERY_MODE: 1, AOV_REFLECTANCE: reflectance ? 1 : 0 } };
+            const compute = { ...this._depthCompute, constants: { ...this._depthCompute.constants, DEPTH_QUERY_MODE: 1, AOV_REFLECTANCE: reflectance ? 1 : 0, AOV_COMPACT: compact ? 1 : 0 } };
             // Keep the UI responsive during first use, and reuse both variants across
             // preview/final target changes rather than recreating synchronous pipelines.
             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;
         return pipelines;
     }
-    prepareAovs(kinds) {
-        const pipelines = this._prepareAovPipelines(kinds);
+    prepareAovs(kinds, compact = false) {
+        const pipelines = this._prepareAovPipelines(kinds, compact);
         return !!pipelines?.accumulation && !!pipelines.center;
     }
-    renderAovs(state, camera, samples, cap, kinds) {
+    renderAovs(state, camera, samples, cap, kinds, resolution) {
         const groups = this._rayTraceBindGroups;
         if (!groups || !this._tlas || !this._preparedMeshData || !kinds.length)
             return false;
-        const pipelines = this._prepareAovPipelines(kinds);
+        const compact = !!resolution && kinds.every(kind => COMPACT_AOV_KINDS.includes(kind));
+        const pipelines = this._prepareAovPipelines(kinds, compact);
         if (!pipelines?.accumulation || !pipelines.center)
             return false;
-        state.resize(this._width, this._height);
+        state.resize(resolution?.width ?? this._width, resolution?.height ?? this._height, compact);
         const textures = this._bindless, groupIndex = textures ? 2 : 3;
         const target = Math.min(samples, cap);
         if (state.centerReady && state.samples >= target)
             return true;
         if (!state.frame) {
-            const primitiveIds = this._aovPrimitiveCache.get(this._preparedMeshData, this._tlas);
-            const packed = packAovScene(this._preparedMeshData, this._tlas, camera, this._width, this._height, state.history, primitiveIds, false);
+            // Only the center pass reads primitive IDs and compact display AOVs skip
+            // it; building the map walks every BVH leaf on the main thread.
+            const primitiveIds = compact ? undefined : this._aovPrimitiveCache.get(this._preparedMeshData, this._tlas);
+            const packed = packAovScene(this._preparedMeshData, this._tlas, camera, state.width, state.height, state.history, primitiveIds, false);
             state.frame = packed.frame;
             state.setScene(packed.words, primitiveIds);
         }
         this._device.queue.writeBuffer(this._uniforms.rtUniform, 0, this._rtUniform.buffer);
-        this._device.queue.writeBuffer(this._uniforms.cameraUniform, 0, packCameraUniform(this._viewProjInv, this._cameraWorld, this._apertureRadius, this._focusDistance));
+        this._device.queue.writeBuffer(this._uniforms.cameraUniform, 0, packCameraUniform(this._viewProjInv, this._cameraWorld, this._apertureRadius, this._focusDistance, this._projectionInv));
         const device = this._device;
         const run = (pipeline, sample) => {
             // A fresh uniform for each queued dispatch keeps batch samples independent.
@@ -943,11 +1064,12 @@ class WGPURayTracePass {
             parameters.destroy();
         };
         if (!state.centerReady) {
-            run(pipelines.center, 0);
+            if (!compact)
+                run(pipelines.center, 0);
             state.centerReady = true;
             state.history.accept(state.frame);
         }
-        if ((aovMask(kinds) & 31) === 0)
+        if ((aovMask(kinds) & AOV_ACCUMULATED_MASK) === 0)
             state.samples = target;
         while (state.samples < target) {
             run(pipelines.accumulation, state.samples);
@@ -955,13 +1077,27 @@ class WGPURayTracePass {
         }
         return true;
     }
-    async readDepthSamples(area, aspect) {
+    async pickSurface(x, y, aspect) {
+        const source = this._preparedMeshData, tlas = this._tlas;
+        if (!source || !tlas)
+            return;
+        const values = await this._readDepthSamples({ x, y, size: 0 }, aspect, true);
+        if (!values || source !== this._preparedMeshData || tlas !== this._tlas)
+            return;
+        return resolveSurfaceHit(source, tlas, values);
+    }
+    readDepthSamples(area, aspect) {
+        return this._readDepthSamples(area, aspect);
+    }
+    async _readDepthSamples(area, aspect, picking = false) {
         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 (picking)
+            packed.set([-1, -1], 2);
         if (this._depthTracePipeline !== tracePipeline || !this._depthPipeline) {
             const outputLayout = this._shaderCache.createBindGroupLayout({
                 label: 'Depth query output',
@@ -1013,7 +1149,8 @@ class WGPURayTracePass {
             encoder.copyBufferToBuffer(output, 0, readback, 0, bytes);
             device.queue.submit([encoder.finish()]);
             await readback.mapAsync(GPUMapMode.READ);
-            return unpackDepthSamples(new Float32Array(readback.getMappedRange()));
+            const rgba = new Float32Array(readback.getMappedRange());
+            return picking ? rgba.slice(0, 4) : unpackDepthSamples(rgba);
         }
         finally {
             if (readback.mapState === 'mapped')
@@ -1023,15 +1160,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 +1193,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 +1214,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 +1227,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 +1248,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 +1304,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,16 +1353,40 @@ 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) {
-            throw new Error(`software-bvh exposes no CPU-readable BVH debug buffer`);
-        }
-        return {
-            buffer: this._debugBVHBuffer
-        };
+        if (!this._bvhCPU)
+            throw new Error('software-bvh exposes no CPU-readable BVH debug buffer');
+        // Debug capture pays for a combined copy only when explicitly requested.
+        const buffer = new ArrayBuffer(this._bvhDataBytes);
+        this._writeBVH(buffer, this._bvhCPU.tlas, this._bvhCPU.blases);
+        return { buffer };
     }
     getDiagnostics() {
         const atlas = this._materialData instanceof MaterialTable ? this._materialData.textureAtlasStats : undefined;
@@ -1174,7 +1401,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,22 +1421,13 @@ 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() {
         return this._apertureRadius > 0;
     }
     setBounce(bounce) {
-        const next = normalizeBounces(bounce);
+        const next = normalizeBounces(bounce, MAX_PATH_EVENTS_WGPU);
         const changed = this._bounces !== next;
         this._bounces = next;
         this._rtUniform.views.bounces[0] = next;
@@ -1265,8 +1483,30 @@ class WGPURayTracePass {
         this._ensureAdaptiveSamplingTexture(width, height);
         this._device.queue.writeTexture({ texture: this._adaptiveSamplingTexture }, data, { bytesPerRow: width * Float32Array.BYTES_PER_ELEMENT }, [width, height]);
     }
+    _shareSpectralPrefix = true;
     setQuality(options) {
-        writeTraceQuality(this._rtUniform.views, options);
+        this._shareSpectralPrefix = options.dispersionWavelengths !== 1;
+        WGPURayTracePass.prototype._setCaustics.call(this, options.caustics);
+        writeTraceQuality(this._rtUniform.views, options, MAX_PATH_EVENTS_WGPU);
+    }
+    _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;
@@ -1621,14 +1861,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]) {
@@ -1675,22 +1920,54 @@ class WGPURayTracePass {
         const stacks = getTraversalStackSizes(tlas, blases);
         this._constants.TLAS_STACK_SIZE = retainedShaderCapacity(stacks.tlas, Number(this._constants.TLAS_STACK_SIZE ?? 0));
         this._constants.BLAS_STACK_SIZE = retainedShaderCapacity(stacks.blas, Number(this._constants.BLAS_STACK_SIZE ?? 0), 32);
-        const tlasBuffer = new Float32Array(tlas.buffer);
-        const blasBuffer = new Float32Array(concatBLASBuffers(blases));
-        const bvhData = new Float32Array(tlasBuffer.length + blasBuffer.length);
-        const blasOffset = tlasBuffer.length / 4;
-        bvhData.set(tlasBuffer);
-        bvhData.set(blasBuffer, blasOffset * 4);
-        const bvhBuffer = this._updateGPUBuffer('BVH', this._bvhBuffer, bvhData);
+        const size = tlas.buffer.byteLength + blases.reduce((sum, b) => sum + b.bvh.buffer.byteLength, 0);
+        const limit = Math.min(this._device.limits.maxBufferSize, this._device.limits.maxStorageBufferBindingSize);
+        if (size > limit)
+            throw new RangeError(`BVH buffer requires ${size} bytes; device storage buffer limit is ${limit} bytes.`);
+        let bvhBuffer = this._bvhBuffer;
+        if (!bvhBuffer || bvhBuffer.size < Math.max(size, WGPU_SCENE_BUFFER_MIN_BYTES)) {
+            bvhBuffer?.destroy();
+            bvhBuffer = this._device.createBuffer({ label: 'BVH', size: Math.max(size, WGPU_SCENE_BUFFER_MIN_BYTES),
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC, mappedAtCreation: size < 0x80000000 });
+            if (size < 0x80000000) {
+                this._writeBVH(bvhBuffer.getMappedRange(), tlas, blases);
+                bvhBuffer.unmap();
+            }
+            else
+                this._uploadBVHBlocks(bvhBuffer, tlas, blases);
+        }
+        else
+            this._uploadBVHBlocks(bvhBuffer, tlas, blases);
+        this._bvhCPU = { tlas, blases };
+        this._bvhDataBytes = size;
+        const blasOffset = tlas.buffer.byteLength / 16;
         const instancesBuffer = this._updateGPUBuffer('Instances', this._instancesBuffer, new Float32Array(tlas.instancesBuffer));
-        if (bvhBuffer !== this._bvhBuffer || instancesBuffer !== this._instancesBuffer) {
+        if (bvhBuffer !== this._bvhBuffer || instancesBuffer !== this._instancesBuffer)
             this._needsUpdateBindGroups = true;
-        }
         this._bvhBuffer = bvhBuffer;
         this._instancesBuffer = instancesBuffer;
-        this._debugBVHBuffer = bvhData.buffer.slice(0);
         this._rtUniform.views.blasOffset.set([blasOffset]);
     }
+    _uploadBVHBlocks(buffer, tlas, blases) {
+        this._device.queue.writeBuffer(buffer, 0, tlas.buffer);
+        let target = tlas.buffer.byteLength;
+        for (const blas of blases) {
+            const chunkBytes = 64 * 1024 * 1024;
+            for (let offset = 0; offset < blas.bvh.buffer.byteLength; offset += chunkBytes) {
+                this._device.queue.writeBuffer(buffer, target + offset, blas.bvh.buffer, offset, Math.min(chunkBytes, blas.bvh.buffer.byteLength - offset));
+            }
+            target += blas.bvh.buffer.byteLength;
+        }
+    }
+    _writeBVH(buffer, tlas, blases) {
+        const bytes = new Uint8Array(buffer);
+        bytes.set(new Uint8Array(tlas.buffer));
+        let offset = tlas.buffer.byteLength;
+        for (const blas of blases) {
+            bytes.set(new Uint8Array(blas.bvh.buffer), offset);
+            offset += blas.bvh.buffer.byteLength;
+        }
+    }
     _updateMeshData() {
         this._pendingGeometryUpdates.clear();
         this._emissiveCache = new EmissiveTriangleCache();
@@ -1705,7 +1982,7 @@ class WGPURayTracePass {
         }
         this._geometriesNeedRefit.clear();
         // TODO check bvh needs to change
-        const res = updateMeshInstances(meshes);
+        const res = updateMeshInstances(meshes, { mergeAttributes: false });
         this._preparedMeshData = res;
         this._membershipCache.capture(res);
         this._pendingMembershipData = undefined;
@@ -1713,7 +1990,7 @@ class WGPURayTracePass {
         const mergedGeometry = res.geometry;
         const materials = res.materials;
         const isEmpty = meshes.length === 0 || res.instances.length === 0;
-        const tlas = buildTLAS(res.instances, res.blases);
+        const tlas = buildWebTLAS(res.instances, res.blases);
         this._tlas = tlas;
         this._uploadBVH(tlas, res.blases);
         const materialData = (this._materialData = this._createMaterialData(materials, this._analyticLights, {
@@ -1723,13 +2000,23 @@ class WGPURayTracePass {
         }));
         this._emissiveTriangles = this._emissiveCache.collect(res.emissiveBindings, materials);
         this._needsUpdateLightSamplingData = true;
-        const attributeLayout = sceneAttributeLayout(mergedGeometry);
+        // Displacement geometry and its CPU BVH bounds must use the same normal.
+        // Preserve f32 normals in these scenes, avoiding quantization outside bounds.
+        const attributeLayout = compactVertexLayout(res.geometries, materials.some(m => !!m.displacementMap));
         const { stride, offsets } = attributeLayout;
-        const attrBufferData = new F32(mergedGeometry.vertexCount * stride);
-        packVertexAttributes(mergedGeometry, attrBufferData, stride, offsets, 0, mergedGeometry.vertexCount);
+        const vertexWords = res.geometries.reduce((sum, g) => sum + g.vertexCount, 0) * stride;
+        const materialWords = attributeLayout.constants.HAS_TRIANGLE_MATERIAL ? this._bvhDataBytes / 16 : 0;
+        const attrBufferData = new Uint32Array(vertexWords + materialWords);
+        attributeLayout.constants.MATERIALINDEX_OFF = vertexWords;
+        for (const geometry of res.geometries) {
+            const region = res.geometryRegions.get(geometry);
+            packCompactVertices(geometry, attrBufferData, stride, offsets, 0, geometry.vertexCount, region.vertexOffset, false, !!attributeLayout.constants.COLOR_FLOAT, !!attributeLayout.constants.NORMAL_FLOAT);
+        }
         this._attributeData = attrBufferData;
         this._attributeStride = stride;
         this._attributeOffsets = offsets;
+        Object.assign(this._constants, attributeLayout.constants);
+        this._packTriangleMaterials(res, tlas);
         this._attrBuffers = this._updateGPUBuffer('Attributes', this._attrBuffers, attrBufferData);
         this._materialsBuffer = this._updateGPUBuffer('Materials', this._materialsBuffer, materialData.getBufferArray(), 
         // WGSL requires a runtime array binding to contain at least one
@@ -1770,21 +2057,53 @@ 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)
             this._constants.NUM_MAPS = 20;
     }
+    _packTriangleMaterials(res, tlas) {
+        if (!this._constants.HAS_TRIANGLE_MATERIAL)
+            return;
+        let offset = Number(this._constants.MATERIALINDEX_OFF) + tlas.buffer.byteLength / 16;
+        res.geometries.forEach((g, i) => {
+            packTriangleMaterials(g, res.geometryRegions.get(g).materialIndices, res.blases[i].bvh.buffer, this._attributeData, offset);
+            offset += res.blases[i].bvh.buffer.byteLength / 16;
+        });
+    }
+    _refreshTriangleMaterials(res, tlas) {
+        if (!this._constants.HAS_TRIANGLE_MATERIAL)
+            return;
+        const vertexWords = Number(this._constants.MATERIALINDEX_OFF);
+        const required = vertexWords + this._bvhDataBytes / 16;
+        if (this._attributeData.length !== required) {
+            const next = new Uint32Array(required);
+            next.set(this._attributeData.subarray(0, vertexWords));
+            this._attributeData = next;
+        }
+        this._packTriangleMaterials(res, tlas);
+        if (this._attrBuffers.size < this._attributeData.byteLength) {
+            this._attrBuffers = this._updateGPUBuffer('Attributes', this._attrBuffers, this._attributeData);
+        }
+        else {
+            const first = vertexWords * 4, end = this._attributeData.byteLength, chunk = 64 * 1024 * 1024;
+            for (let offset = first; offset < end; offset += chunk) {
+                this._device.queue.writeBuffer(this._attrBuffers, offset, this._attributeData.buffer, offset, Math.min(chunk, end - offset));
+            }
+        }
+    }
     _updateGeometryData() {
         const res = this._preparedMeshData, tlas = this._tlas;
+        // Promote the scene color plane if an edit introduces HDR/negative RGB.
+        if (!this._constants.COLOR_FLOAT && [...this._pendingGeometryUpdates].some(g => g.color?.array.some(value => !(value >= 0 && value <= 1)))) {
+            this._updateMeshData();
+            return;
+        }
         const update = updatePreparedGeometries(res, this._pendingGeometryUpdates);
-        for (const { first, count, topologyChanged, deformationOnly } of update.vertices) {
-            packVertexAttributes(res.geometry, this._attributeData, this._attributeStride, this._attributeOffsets, first, count, topologyChanged, deformationOnly);
+        for (const { first, count, deformationOnly } of update.vertices) {
+            const geometry = res.geometries.find(g => res.geometryRegions.get(g).vertexOffset === first);
+            packCompactVertices(geometry, this._attributeData, this._attributeStride, this._attributeOffsets, 0, count, first, deformationOnly, !!this._constants.COLOR_FLOAT, !!this._constants.NORMAL_FLOAT);
             const offset = first * this._attributeStride * 4, size = count * this._attributeStride * 4;
             this._device.queue.writeBuffer(this._attrBuffers, offset, this._attributeData.buffer, offset, size);
         }
@@ -1800,17 +2119,13 @@ class WGPURayTracePass {
             this._uploadBVH(tlas, res.blases);
         }
         else {
-            const bytes = new Uint8Array(this._debugBVHBuffer);
-            const ranges = [];
             for (const { blas, offset } of update.blases) {
-                const target = tlas.buffer.byteLength + offset;
-                bytes.set(new Uint8Array(blas.buffer), target);
-                ranges.push({ offset: target, size: blas.buffer.byteLength });
-            }
-            for (const { offset, size } of mergeRefitRanges(ranges)) {
-                this._device.queue.writeBuffer(this._bvhBuffer, offset, this._debugBVHBuffer, offset, size);
+                this._device.queue.writeBuffer(this._bvhBuffer, tlas.buffer.byteLength + offset, blas.buffer);
             }
         }
+        if (this._constants.HAS_TRIANGLE_MATERIAL && (update.relocated || update.vertices.some(v => v.topologyChanged))) {
+            this._refreshTriangleMaterials(res, tlas);
+        }
         const bits = { bvh2: 1, bvh4: 2, 'bvh-gpu': 4, cwbvh: 8 };
         this._blasLayoutMask = res.blases.reduce((mask, b) => mask | bits[b.bvh.layout ?? 'bvh2'], 0);
         const stacks = getTraversalStackSizes(tlas, res.blases);
@@ -1870,9 +2185,10 @@ class WGPURayTracePass {
         if (pending)
             this._residentPreparedMeshData = res;
         this._pendingMembershipData = undefined;
-        const tlas = buildTLAS(instances, res.blases);
+        const tlas = buildWebTLAS(instances, res.blases);
         this._tlas = tlas;
         this._uploadBVH(tlas, res.blases);
+        this._refreshTriangleMaterials(res, tlas);
         this._emissiveTriangles = this._emissiveCache.collect(emissiveBindings, res.materials);
         this._needsUpdateLightSamplingData = true;
         this._rtUniform.views.isEmpty[0] = +(instances.length === 0);
@@ -1906,8 +2222,9 @@ class WGPURayTracePass {
         const previousInstances = res.instances;
         res.instances = updateMeshInstanceTransforms(res.instanceBindings, incremental ? res.instances : undefined, incremental ? dirtyIndices : undefined);
         if (!sameInstanceMembership(previousInstances, res.instances)) {
-            this._tlas = buildTLAS(res.instances, res.blases);
+            this._tlas = buildWebTLAS(res.instances, res.blases);
             this._uploadBVH(this._tlas, res.blases);
+            this._refreshTriangleMaterials(res, this._tlas);
             this._emissiveTriangles = this._emissiveCache.collect(res.emissiveBindings, res.materials);
             this._needsUpdateLightSamplingData = true;
             this._rtUniform.views.isEmpty[0] = +(res.instances.length === 0);
@@ -1916,16 +2233,12 @@ class WGPURayTracePass {
             return;
         }
         const ranges = refitTLAS(tlas, res.instances, res.blases, incremental ? dirtyIndices : undefined);
-        const tlasData = new Float32Array(tlas.buffer);
         for (const { offset, size } of ranges.tlasRanges) {
             this._device.queue.writeBuffer(this._bvhBuffer, offset, tlas.buffer, offset, size);
         }
         for (const { offset, size } of ranges.instanceRanges) {
             this._device.queue.writeBuffer(this._instancesBuffer, offset, tlas.instancesBuffer, offset, size);
         }
-        if (this._debugBVHBuffer) {
-            new Float32Array(this._debugBVHBuffer).set(tlasData);
-        }
         if (!incremental ||
             res.emissiveBindings.some(({ mesh }) => this._dirtyTransformMeshes.has(mesh))) {
             this._emissiveTriangles = this._emissiveCache.collect(res.emissiveBindings, res.materials);
@@ -1945,8 +2258,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,10 +2369,15 @@ 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;
-        this._updateViewProjInv(camera, viewProjectionInvMat);
+        mat4.invert(this._projectionInv, projection);
+        mat4.mul(viewProjectionInvMat, camera.transform, this._projectionInv);
         mat4.copy(this._cameraWorld, camera.transform);
     }
     cameraChanged(camera) {
@@ -2117,7 +2433,7 @@ class WGPURayTracePass {
         const arr = this._rtUniform.views.jitter;
         arr[0] = x;
         arr[1] = y;
-        this._device.queue.writeBuffer(this._uniforms.cameraUniform, 0, packCameraUniform(this._viewProjInv, this._cameraWorld, this._apertureRadius, this._focusDistance));
+        this._device.queue.writeBuffer(this._uniforms.cameraUniform, 0, packCameraUniform(this._viewProjInv, this._cameraWorld, this._apertureRadius, this._focusDistance, this._projectionInv));
     }
     setSampleTiles(columns, rows, tileX, tileY) {
         const arr = this._rtUniform.views.scaleOffset;
@@ -2147,12 +2463,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 +2490,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;
     }