@meimu/mutracer 0.1.5 → 0.3.0

package/lib/renderer/WGPURayTracePass.js

@@ -1,7 +1,28 @@
+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 { proceduralEnvironmentPower } from './proceduralEnvironmentPower.js';
+import { WGPUSkyBaker } from './WGPUSkyBaker.js';
+import { initialSceneConstants, sceneAttributeLayout, 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';
+import { bindlessBindGroupLayouts, bindlessShaderSource } from './wgpuBindlessSource.js';
+import { bindlessLimitReason, resourceTableLayout, setResourceTable } from './wgpuBindless.js';
+import { wgpuMaterialConstants } from './wgpuMaterialConstants.js';
+import { wgpuShaderSource, wgpuPipelineConstantKeys, WGPU_SHADER_DEFINE_KEYS } from './wgpuShaderSource.js';
+import { makeRayTraceUniform, WGPU_SCENE_BUFFER_MIN_BYTES } from './wgpuSceneUniform.js';
 import { constants } from './webgl.js';
-import { MATERIAL_FLOAT_COUNT } from './materialLayout.js';
+import { MATERIAL_FLOAT_COUNT } from './materialLayoutSchema.js';
 import { normalizeBounces } from './pathLimits.js';
-import { MATERIAL_TEXTURE_DEFINES, materialTextureFeatures } from './materialTextureSlots.js';
 import { updateMeshInstanceColors } from './prepareMeshBVH.js';
 import { updateTLASInstanceColors } from './bvhAccel.js';
 import { getMaterialHashKey } from '../scene/openPbrSchema.js';
@@ -9,31 +30,31 @@ import { sameInstanceMembership } from './meshInstances.js';
 import InstancedMesh from '../scene/InstancedMesh.js';
 import { dirtyMeshInstanceIndices } from './prepareMeshBVH.js';
 import { cameraApertureRadius } from './cameraLens.js';
-import { getRectLightUOrV, getRectLightArea, getSphereLightArea, getSpotLightArea, getSpotLightRadiance, getLightDirection, getRigidLightFrame, validateSceneLights } from './lightsUtil.js';
 import { getGeometryBvh, setGeometryBvh } from './geometryBvh.js';
+import { packCameraUniform } from './cameraUniform.js';
 import { SHADOW_CATCHER_ACCUMULATION_BYTES } from './wgsl/chunks/shadowCatcherAccumulation.wgsl.js';
-import { samplingPatternCode, zSobolLog2SPP } from './sampling.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 { SceneEnvironmentCache, RectLightTextureTracker } from './sceneLightChanges.js';
 import { MaterialChangeTracker, materialIsEmissive } from './materialChanges.js';
+import { WGPUEnvMapDistribution } from './WGPUEnvMapDistribution.js';
 import { WGPUShaderCache, retainedShaderCapacity } from './WGPUShaderCache.js';
-import { WGPU_SCENE_FEATURE_BITS, wgpuSceneFeatureFlags } from './WGPUSceneFeatures.js';
+import { WGPUShaderCapabilities } from './WGPUShaderCapabilities.js';
+import { wgpuSceneFeatureFlags } from './WGPUSceneFeatures.js';
+import { lightShaderCapabilities, retainedShaderCapabilities } from './shaderCapabilities.js';
 import { mat4 } from '../math.js';
-import MaterialTable, { DEFAULT_MAX_TEXTURE_ARRAY_BYTES, materialUsesMedium } from './MaterialTable.js';
+import MaterialTable, { DEFAULT_MAX_TEXTURE_ARRAY_BYTES } from './MaterialTable.js';
 import { numberArraysEqual } from './util.js';
-import { generateBackgroundMapFromSceneBackground, environmentRotation, backgroundMapTransform } from './envMapCreation.js';
-import rayTraceCompute, { WORKGROUP_SIZE } from './wgsl/rayTrace.compute.js';
-import { CONSTANT_DIRECTIONAL_LIGHT, CONSTANT_RECT_LIGHT, CONSTANT_SPHERE_LIGHT, CONSTANT_SPOT_LIGHT } from './lightsUtil.js';
+import { generateBackgroundMapFromSceneBackground, environmentRotation, backgroundMapTransform, backgroundMapRotation } from './envMapCreation.js';
+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 { isTextureDataSource } from '../scene/Texture.js';
-import { resolveMaterialAlphaMode } from '../scene/OpenPBRMaterial.js';
 import { DEFAULT_BEVEL_SAMPLES, DEFAULT_DIRECT_LIGHT_CANDIDATES, normalizeBevelSamples, normalizeDirectLightCandidates } from './RenderingPipeline.js';
-import { buildLightAliasTable, EmissiveTriangleCache, LightChoiceBuffer, estimateAnalyticLightPower, estimateEnvironmentPower, LIGHT_CHOICE_ANALYTIC, LIGHT_CHOICE_EMISSIVE_TRIANGLE, LIGHT_CHOICE_ENVIRONMENT, LIGHT_DOMAIN_ENVIRONMENT, LIGHT_DOMAIN_INFINITE, LIGHT_DOMAIN_LOCAL_AND_EMISSIVE, packEmissiveTriangles, packIESProfiles } 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';
@@ -65,6 +86,10 @@ function joinWebGPUErrors(...errors) {
             .filter(Boolean))
     ].join('\n');
 }
+const MAX_TRACE_VARIANTS = 32;
+// Requests are cheap but drivers are not, and a running compilation cannot be cancelled.
+const MAX_CONCURRENT_COMPILES = 2;
+const MAX_QUEUED_COMPILES = 4;
 function shaderCompilationNow() {
     return typeof performance === 'undefined' ? Date.now() : performance.now();
 }
@@ -87,124 +112,29 @@ export function isWebGPUPipelineSpecializationFailure(...errors) {
     return errors.some((error) => /(?:compute )?library failed creation/i.test(getWebGPUErrorMessage(error)));
 }
 /** CPU-side views over the `RayTraceUniform` WGSL struct. */
-export function makeRayTraceUniform() {
-    // Created from https://webgpufundamentals.org/webgpu/lessons/resources/wgsl-offset-computer.html
-    const RayTraceUniformValues = new ArrayBuffer(256);
-    const RayTraceUniformViews = {
-        outputSize: new Float32Array(RayTraceUniformValues, 0, 2),
-        sampleCount: new Float32Array(RayTraceUniformValues, 8, 1),
-        scaleOffset: new Float32Array(RayTraceUniformValues, 16, 4),
-        lightsCount: new Int32Array(RayTraceUniformValues, 32, 1),
-        transmissiveOutputAlphaMin: new Float32Array(RayTraceUniformValues, 36, 1),
-        jitter: new Float32Array(RayTraceUniformValues, 40, 2),
-        backgroundColor: new Float32Array(RayTraceUniformValues, 48, 4),
-        groundedBackgroundParams: new Float32Array(RayTraceUniformValues, 64, 4),
-        groundedBackgroundCenter: new Float32Array(RayTraceUniformValues, 80, 2),
-        blasOffset: new Int32Array(RayTraceUniformValues, 88, 1),
-        isEmpty: new Int32Array(RayTraceUniformValues, 92, 1),
-        bevel: new Int32Array(RayTraceUniformValues, 96, 1),
-        dispersionWavelengths: new Int32Array(RayTraceUniformValues, 100, 1),
-        envLightPmf: new Float32Array(RayTraceUniformValues, 104, 1),
-        lightChoiceCount: new Int32Array(RayTraceUniformValues, 108, 1),
-        lightWeightTotal: new Float32Array(RayTraceUniformValues, 112, 1),
-        lightSamplingTextureWidth: new Int32Array(RayTraceUniformValues, 116, 1),
-        lightChoiceTexelOffset: new Int32Array(RayTraceUniformValues, 120, 1),
-        bounces: new Int32Array(RayTraceUniformValues, 124, 1),
-        varianceMoments: new Int32Array(RayTraceUniformValues, 128, 1),
-        adaptiveSampling: new Int32Array(RayTraceUniformValues, 132, 1),
-        clamping: new Float32Array(RayTraceUniformValues, 136, 1),
-        directLightCandidates: new Int32Array(RayTraceUniformValues, 140, 1),
-        backgroundFlags: new Int32Array(RayTraceUniformValues, 144, 1),
-        loopUnrollGuard: new Uint32Array(RayTraceUniformValues, 148, 1),
-        sceneFeatureFlags: new Uint32Array(RayTraceUniformValues, 152, 1),
-        sequenceSeed: new Uint32Array(RayTraceUniformValues, 156, 1),
-        zSobolLogSPP: new Uint32Array(RayTraceUniformValues, 160, 1),
-        sampleSequenceOffset: new Uint32Array(RayTraceUniformValues, 164, 1),
-        environmentRotation: new Float32Array(RayTraceUniformValues, 176, 16),
-        backgroundMapTransform: new Float32Array(RayTraceUniformValues, 240, 4)
-    };
-    // Fixed runtime trip bounds discourage thin-film loop unrolling. Keep 4 for
-    // 2 polarizations/substrates and 3 channels, independent of BSDF budgets.
-    RayTraceUniformViews.loopUnrollGuard[0] = 4;
-    RayTraceUniformViews.environmentRotation.set(environmentRotation([]));
-    RayTraceUniformViews.backgroundMapTransform.set(backgroundMapTransform());
-    RayTraceUniformViews.bevel[0] = 1;
-    RayTraceUniformViews.dispersionWavelengths[0] = 3;
-    return {
-        buffer: RayTraceUniformValues,
-        views: RayTraceUniformViews
-    };
-}
+export { makeRayTraceUniform } from './wgpuSceneUniform.js';
 export function packAnalyticsLightsToBuffer(lights, texturesIndices, selectionPmfs, iesProfileTexelOffsets = []) {
-    validateSceneLights(lights);
-    const numLights = lights.length;
-    if (numLights > FIXED_LIGHT_COUNT) {
-        console.warn(`Too many lights, only the first ${FIXED_LIGHT_COUNT} lights will be used.`);
-    }
-    const data = new Float32Array(numLights * PIXELS_PER_LIGHT * 4);
-    function packVec3(idx, v) {
-        for (let i = 0; i < 3; i++) {
-            data[i + idx * 4] = v[i];
-        }
-    }
-    const lightTypeConstants = {
-        DirectionalLight: CONSTANT_DIRECTIONAL_LIGHT,
-        SphereLight: CONSTANT_SPHERE_LIGHT,
-        RectLight: CONSTANT_RECT_LIGHT,
-        SpotLight: CONSTANT_SPOT_LIGHT
-    };
-    for (let i = 0; i < numLights; i++) {
-        const light = lights[i];
-        const color = light.color;
-        const intensity = light.intensity;
-        const off = i * PIXELS_PER_LIGHT;
-        packVec3(off, light.position);
-        data[off * 4 + 3] = lightTypeConstants[light.type];
-        // emission
-        const emissionScale = light.type === 'SpotLight' ? getSpotLightRadiance(light) : intensity;
-        packVec3(off + 1, [
-            color[0] * emissionScale,
-            color[1] * emissionScale,
-            color[2] * emissionScale
-        ]);
-        if (light.type === 'RectLight') {
-            data[(off + 1) * 4 + 3] = getRectLightArea(light);
-            packVec3(off + 2, getRectLightUOrV(light, 0));
-            data[(off + 2) * 4 + 3] = light.spread;
-            packVec3(off + 3, getRectLightUOrV(light, 1));
-        }
-        else if (light.type === 'SphereLight') {
-            data[(off + 1) * 4 + 3] = getSphereLightArea(light);
-            data[(off + 2) * 4 + 3] = light.radius;
-        }
-        else if (light.type === 'SpotLight') {
-            data[(off + 1) * 4 + 3] = getSpotLightArea(light);
-            packVec3(off + 2, getLightDirection(light));
-            data[(off + 2) * 4 + 3] = light.radius;
-            packVec3(off + 3, [
-                Math.cos((light.outerAngle * Math.PI) / 180),
-                Math.cos((Math.min(light.innerAngle, light.outerAngle) * Math.PI) / 180),
-                0
-            ]);
-        }
-        else if (light.type === 'DirectionalLight') {
-            packVec3(off + 2, getLightDirection(light));
-        }
-        data[(off + 3) * 4 + 3] = light.type === 'SpotLight'
-            ? iesProfileTexelOffsets[i] ?? -1
-            : texturesIndices[i] ?? -1;
-        data[(off + 4) * 4] = selectionPmfs[i] ?? 0;
-        packVec3(off + 5, getRigidLightFrame(light).x);
-    }
-    return data;
+    return packSceneAnalyticLights(lights, texturesIndices, selectionPmfs, i => iesProfileTexelOffsets[i]);
 }
 class WGPURayTracePass {
+    _textureSelection;
+    _aovPrimitiveCache = new AovPrimitiveCache();
     _device;
     _rayTracePipeline;
     _targetAspect = 1;
     _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 = [];
@@ -212,6 +142,9 @@ class WGPURayTracePass {
     _materialChanges = new MaterialChangeTracker();
     _pendingMaterialUpdate;
     _materialData;
+    _bindless;
+    _retiredBindless = new Set();
+    _disposed = false;
     _maxTextureArrayBytes = DEFAULT_MAX_TEXTURE_ARRAY_BYTES;
     _pendingGeometryUpdates = new Set();
     _needsUpdateMeshData = true;
@@ -236,6 +169,8 @@ class WGPURayTracePass {
         if (!output)
             return;
         this._targetOutputs.delete(target);
+        this._causticLight?.release(target);
+        this._photonMap?.release(target);
         for (const buffer of output.buffers)
             buffer.destroy();
         if (this._activeTarget === target) {
@@ -244,17 +179,23 @@ class WGPURayTracePass {
         }
     }
     getTargetMemoryBytes(target) {
-        return this._targetOutputs.get(target)?.buffers.reduce((sum, buffer) => sum + buffer.size, 0) ?? 0;
+        return ((this._targetOutputs.get(target)?.buffers.reduce((sum, buffer) => sum + buffer.size, 0) ?? 0) +
+            (this._causticLight?.bytes(target) ?? 0) +
+            (this._photonMap?.bytes(target) ?? 0));
     }
     useTarget(target) {
+        if (this._photonMapping && this._activeTarget !== target)
+            this._needsPhotonTargetBindGroups = true;
         this._activeTarget = target;
         const output = this._targetOutputs.get(target);
-        [this._outColorBuffer, this._outNormalBuffer, this._outAlbedoBuffer, this._outShadowCatcherBuffer] = output?.buffers ?? [];
+        [this._outColorBuffer, this._outNormalBuffer, this._outAlbedoBuffer, this._outShadowCatcherBuffer] =
+            output?.buffers ?? [];
         if (output?.bindGroup && output.pipeline === this._rayTracePipeline && this._rayTraceBindGroups) {
-            this._rayTraceBindGroups[3] = output.bindGroup;
+            this._rayTraceBindGroups[this._bindless ? 2 : 3] = output.bindGroup;
+            this._needsUpdateOutputBindGroup = false;
         }
         else {
-            this._needsUpdateBindGroups = true;
+            this._needsUpdateOutputBindGroup = true;
         }
     }
     _outColorBuffer;
@@ -281,6 +222,7 @@ class WGPURayTracePass {
     _instancesBuffer;
     _emissiveCache = new EmissiveTriangleCache();
     _lightChoices = new LightChoiceBuffer();
+    _shadowCatcherLightChoices = new LightChoiceBuffer();
     _lightSamplingData;
     _lightSamplingScratch;
     _lightSamplingTriangleCount = -1;
@@ -296,26 +238,29 @@ class WGPURayTracePass {
     _envImageSource;
     _envTex;
     _envDistributionTex;
+    _envDistribution;
+    _skyBaker;
     _backgroundImageSource;
     _backgroundTex;
-    _rayTracePipelineLayout;
     _rayTraceBindGroups;
+    _photonEmissionGroups;
     _blasLayoutMask = 1;
-    _compiledBlasLayoutMask = 0;
-    _compiledAnisotropyDirections = false;
-    _compiledCoatNormals = false;
-    _compiledHasAlpha = true;
-    _compiledSceneHasAlpha = true;
     _alphaBlendStrategy = 'stochastic';
-    _constants = {
-        USE_BACKGROUND: false,
-        USE_BACKGROUND_MAP: false,
-        USE_GROUNDED_BACKGROUND: false,
-        SAMPLING_PATTERN: 0,
-        BEVEL_SAMPLES: DEFAULT_BEVEL_SAMPLES
-    };
-    _prevPipelineConstants = {};
-    _prevDefinesCode = '';
+    _constants = initialSceneConstants();
+    _retainedShaderCapabilities;
+    _retainedShaderStructure;
+    _shaderCapabilities = new WGPUShaderCapabilities();
+    _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;
@@ -330,21 +275,26 @@ class WGPURayTracePass {
     _apertureRadius = 0;
     _focusDistance = 10;
     _needsUpdateBindGroups = true;
-    _computeShaderModule;
+    // Photon maps are per target. Switching targets only rebinds them, which
+    // must not send steady frames through the asynchronous pipeline path.
+    _needsPhotonTargetBindGroups = false;
+    // Target selection is not a scene-resource edit. A stale fallback must not
+    // leave global bindings dirty after switching back to a prepared target.
+    _needsUpdateOutputBindGroup = false;
+    _aovPipelines = new WeakMap();
     _depthCompute;
     _depthTracePipeline;
     _depthPipeline;
     _shaderCache;
     _debugBVHBuffer;
-    _isCompilingShader = false;
-    _shaderCompilationDiagnostics;
-    _pipelineError;
     // Fold scene invariants before backend inlining; runtime edits use uniforms.
     _bakePipelineConstants = true;
-    _failedPipelineSignature;
-    constructor(device) {
+    constructor(device, _textureSelection = { requested: 'atlas' }) {
+        this._textureSelection = _textureSelection;
         this._device = device;
         this._shaderCache = new WGPUShaderCache(device);
+        if (_textureSelection.support)
+            this._bindless = new WGPUBindlessTextures(device);
         this._uniforms = {
             cameraUniform: this._uniformBuffer(36 * 4),
             rtUniform: this._uniformBuffer(this._rtUniform.buffer.byteLength),
@@ -382,8 +332,14 @@ class WGPURayTracePass {
         device.queue.writeTexture({ texture: this._adaptiveSamplingTexture }, new Float32Array([Number.MAX_SAFE_INTEGER]), { bytesPerRow: 4 }, [1, 1]);
     }
     getOutputBuffer() {
+        // Another render may have traced since this target's samples were written.
+        const transport = this._targetTransport.get(this._activeTarget) ?? 0;
         return {
             color: this._outColorBuffer,
+            ...(transport & 2 || ((this._transport?.debugGroup ?? -1) >= 0 || causticDiagnostics.debugGroup >= 0) ? { wideHdr: true } : {}),
+            ...(transport & 1 && this._causticLight?.get(this._activeTarget)
+                ? { caustic: this._causticLight.get(this._activeTarget) }
+                : {}),
             normal: this._outNormalBuffer,
             albedo: this._outAlbedoBuffer,
             shadowCatcher: this._outShadowCatcherBuffer
@@ -578,130 +534,28 @@ class WGPURayTracePass {
                 varianceBuffer.destroy();
         }
     }
-    _createPipelineLayout() {
-        //Bind group layouts
-        const commonBufferLayoutEntries = Array.from({ length: 4 }, (_, i) => ({
-            binding: i,
-            visibility: GPUShaderStage.COMPUTE,
-            buffer: {
-                type: 'read-only-storage'
-            }
-        }));
-        const buffersBindGroupLayout = this._shaderCache.createBindGroupLayout({
-            label: 'Buffers',
-            entries: commonBufferLayoutEntries
-        });
-        const textureLayoutEntries = [
-            {
-                binding: 0,
-                visibility: GPUShaderStage.COMPUTE,
-                sampler: {}
-            },
-            {
-                binding: 1,
-                visibility: GPUShaderStage.COMPUTE,
-                texture: {
-                    viewDimension: '2d-array'
-                }
-            },
-            // Map size
-            {
-                binding: 3,
-                visibility: GPUShaderStage.COMPUTE,
-                buffer: {
-                    type: 'uniform'
-                }
-            },
-            // Env map
-            {
-                binding: 4,
-                visibility: GPUShaderStage.COMPUTE,
-                texture: {
-                    viewDimension: '2d',
-                    sampleType: 'unfilterable-float'
-                }
-            },
-            // Env map distribution
-            {
-                binding: 5,
-                visibility: GPUShaderStage.COMPUTE,
-                texture: {
-                    viewDimension: '2d',
-                    sampleType: 'unfilterable-float'
-                }
-            },
-            // Background map
-            {
-                binding: 6,
-                visibility: GPUShaderStage.COMPUTE,
-                texture: {
-                    viewDimension: '2d',
-                    sampleType: 'unfilterable-float'
-                }
-            },
-            {
-                binding: 8,
-                visibility: GPUShaderStage.COMPUTE,
-                texture: {
-                    viewDimension: '2d',
-                    sampleType: 'unfilterable-float'
-                }
-            },
-            {
-                binding: 9,
-                visibility: GPUShaderStage.COMPUTE,
-                texture: {
-                    viewDimension: '2d',
-                    sampleType: 'unfilterable-float'
-                }
-            },
-            {
-                binding: 10,
-                visibility: GPUShaderStage.COMPUTE,
-                texture: {
-                    viewDimension: '2d',
-                    sampleType: 'unfilterable-float'
-                }
-            }
-        ];
-        const texturesBindGroupLayout = this._shaderCache.createBindGroupLayout({
-            label: 'Textures', entries: textureLayoutEntries
-        });
-        const uniformsBindGroupLayout = this._shaderCache.createBindGroupLayout({
-            label: 'Uniforms',
-            entries: [
-                ...Array.from({ length: Object.keys(this._uniforms).length }, (_, i) => ({
-                    binding: i,
-                    visibility: GPUShaderStage.COMPUTE,
-                    buffer: {
-                        type: 'uniform'
-                    }
-                })),
-                ...([])
-            ]
-        });
-        const rayTraceOutBuffersBindGroupLayout = this._shaderCache.createBindGroupLayout({
-            label: 'Ray Trace Out Buffers',
-            entries: [
-                ...Array.from({ length: 4 }, (_, i) => ({
-                    binding: i,
-                    visibility: GPUShaderStage.COMPUTE,
-                    buffer: { type: 'storage' }
-                })),
-                ...([])
-            ]
-        });
-        this._rayTracePipelineLayout = this._shaderCache.createPipelineLayout({
+    _createPipelineLayout(bindless, photonMapping) {
+        const descriptor = {
             label: 'Ray Trace Pipeline Layout',
-            bindGroupLayouts: [
-                buffersBindGroupLayout,
-                texturesBindGroupLayout,
-                uniformsBindGroupLayout,
-                rayTraceOutBuffersBindGroupLayout
-            ]
-        });
+            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);
+            })
+        };
+        return this._shaderCache.createPipelineLayout(bindless ? resourceTableLayout(descriptor) : descriptor);
     }
-    _updateGPUBuffer(label, gpuBuffer, data, minSize = 200) {
+    _updateGPUBuffer(label, gpuBuffer, data, minSize = WGPU_SCENE_BUFFER_MIN_BYTES) {
         const device = this._device;
         const size = Math.max(data.byteLength, minSize);
         if (gpuBuffer == null || gpuBuffer.size < size) {
@@ -727,17 +581,45 @@ 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._needsUpdateMeshData) {
                 this._updateMeshData();
@@ -753,314 +635,420 @@ class WGPURayTracePass {
                 this._updateMeshColors();
             if (this._pendingMaterialUpdate)
                 this._updateMaterialData();
+            this._setCaustics(this._causticSettings);
             if (this._needsUpdateLightSamplingData) {
                 this._updateLightSamplingData();
             }
-            const device = this._device;
-            const constants = this._constants;
-            this._rtUniform.views.sceneFeatureFlags[0] = wgpuSceneFeatureFlags(constants);
-            const hasAlpha = Boolean(constants.HAS_ALPHA_BLEND) &&
-                this._alphaBlendStrategy === 'deterministic-source-over';
+            this._setCaustics(this._causticSettings);
+            if (this._lightTracing || this._photonMapping)
+                this._causticBounds = causticCasterSphere(this._meshes);
+            this._targetTransport.set(this._activeTarget, (+this._lightTracing) | (+this._photonMapping << 1));
+            this._preparePhotonTarget();
+            const pipelineInputs = JSON.stringify([
+                this._constants,
+                this._hasDisplacement,
+                this._alphaBlendStrategy,
+                this._blasLayoutMask,
+                this._bakePipelineConstants,
+                this._causticKey,
+                !!this._bindless
+            ]);
+            // Steady rendering must not repeat capability selection and cache-key
+            // preparation. Dirty resources still take the normal bind-group path.
+            if (pipelineInputs === this._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 hasSceneAlpha = Boolean(constants.HAS_ALPHA);
-            const pipelineSignature = JSON.stringify({
-                constants: Object.keys(constants)
-                    .sort()
-                    .map((key) => [key, constants[key]]),
+            const pipelineConstantsKeys = wgpuPipelineConstantKeys(constants);
+            const defineCode = WGPU_SHADER_DEFINE_KEYS.map((key) => `const ${key} = ${constants[key]};`).join('\n');
+            const structure = {
                 hasDisplacement: this._hasDisplacement,
+                caustics: this._causticKey,
+                bindless: !!this._bindless,
                 hasAlpha,
                 hasSceneAlpha,
                 hasAnisotropyDirections: Boolean(constants.USE_ANISOTROPY_DIRECTIONS),
                 hasCoatNormals: Boolean(constants.USE_COAT_NORMAL_FRAMES),
                 blasLayoutMask: this._blasLayoutMask,
                 bakePipelineConstants: this._bakePipelineConstants
+            };
+            const structureKey = JSON.stringify({
+                ...structure,
+                defineCode,
+                constants: pipelineConstantsKeys
+                    .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;
+            // do not carry unused capabilities across different transport/layouts.
+            const capabilities = this._shaderCapabilities.find(structureKey, requiredCapabilities) ??
+                retainedShaderCapabilities(this._constants, structureKey === this._retainedShaderStructure ? this._retainedShaderCapabilities : undefined);
+            Object.assign(constants, capabilities);
+            // 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,
+                defineCode,
+                constants: pipelineConstantsKeys.map((key) => [key, constants[key]])
             });
-            attemptedPipelineSignature = pipelineSignature;
-            if (pipelineSignature === this._failedPipelineSignature) {
+            const variant = this._traceVariants.get(signature) ??
+                this._startTraceVariant(signature, constants, { hasAlpha, hasSceneAlpha, defineCode, pipelineConstantsKeys, structureKey, capabilities });
+            this._requestedVariant = variant;
+            if (variant.status === 'pending') {
+                this._requestQueuedCompile(variant);
+                return variant.settled;
+            }
+            if (variant.status === 'failed')
                 return;
+            this._installTraceVariant(variant, pipelineInputs);
+        }
+        catch (error) {
+            this._resourceError = error;
+            this._needsUpdateBindGroups = true;
+            console.error('Failed to update WebGPU ray tracing resources.', error);
+        }
+    }
+    /** Runs only for a ready variant, without yielding, so tracing can start in this call. */
+    _installTraceVariant(variant, pipelineInputs) {
+        if (this._activeVariant !== variant) {
+            this._activeVariant = variant;
+            this._rayTracePipeline = variant.pipeline;
+            this._depthCompute = variant.depthCompute;
+            this._needsUpdateBindGroups = true;
+        }
+        const emission = () => causticEmissionTable(this._analyticLights, this._emissiveTriangles, this._causticBounds[3], this._envImageSource && 'sky' in this._envImageSource
+            ? proceduralEnvironmentPower(this._envImageSource)
+            : estimateEnvironmentPower(this._envImageSource));
+        const casters = () => causticDiagnostics.aggregateCasters ? [this._causticBounds] : causticCasterSpheres(this._meshes);
+        if (this._lightTracing && this._causticLight) {
+            this._causticLight.setDistribution(casters(), emission());
+            this._causticLight.use(variant.lightEmitter);
+        }
+        if (this._photonMapping && this._photonMap) {
+            this._photonMap.emission.setDistribution(casters(), emission());
+            this._photonMap.emission.use(variant.photonEmitter);
+        }
+        // TODO rebind when lights, materials, bvh changed.
+        if (this._needsUpdateBindGroups || this._needsPhotonTargetBindGroups || this._needsUpdateOutputBindGroup) {
+            this._needsUpdateBindGroups = false;
+            this._needsPhotonTargetBindGroups = false;
+            this._needsUpdateOutputBindGroup = false;
+            this._updateBindGroups();
+        }
+        this._retainedShaderCapabilities = variant.capabilities;
+        this._retainedShaderStructure = variant.structureKey;
+        this._shaderCapabilities.remember(variant.structureKey, variant.capabilities);
+        this._activeInputs = pipelineInputs;
+    }
+    /** Snapshots everything compilation needs. The task must not read mutable pass state afterwards. */
+    _startTraceVariant(signature, constants, shader) {
+        const bake = this._bakePipelineConstants, bindless = this._bindless;
+        const hasDisplacement = this._hasDisplacement, blasLayoutMask = this._blasLayoutMask;
+        const lightTracing = this._lightTracing, photonMapping = this._photonMapping;
+        const causticKey = this._causticKey, transport = this._transport;
+        const { hasAlpha, hasSceneAlpha, defineCode, pipelineConstantsKeys } = shader;
+        const emitterSource = (mode) => {
+            const code = causticLightCompute(constants, blasLayoutMask, hasDisplacement, mode, '', causticDiagnostics.fullEmissionRandom !== false);
+            return bindless ? bindlessShaderSource(code, this._textureSelection.support.enable) : code;
+        };
+        const lightEmitter = lightTracing ? this._causticLight ??= new WGPUCausticLightPass(this._device) : undefined;
+        const photonEmitter = photonMapping ? this._photonMap?.emission : undefined;
+        const pipelineDiagnostic = {
+            label: 'Ray Trace', entryPoint: 'main', firstFrameRequired: true, status: 'compiling',
+            startedAtMs: 0, concurrentCompilationCount: 1
+        };
+        const variant = {
+            status: 'pending', capabilities: shader.capabilities, structureKey: shader.structureKey,
+            settled: undefined,
+            diagnostics: {
+                status: 'compiling', sourceBytes: 0, sourceLines: 0, pipelineCount: 1,
+                completedPipelineCount: 0, sourceGenerationTimeMs: 0, moduleCreationTimeMs: 0,
+                modules: [], pipelines: [{ ...pipelineDiagnostic }], maximumConcurrentPipelineCount: 1, peakConcurrentPipelineCount: 1
             }
-            this._pipelineError = undefined;
-            // TODO hardcoded defines that will be replaced in the code.
-            const definesKeys = [
-                'NUM_MAPS',
-                'TLAS_STACK_SIZE',
-                'BLAS_STACK_SIZE',
-                'NUM_UNIFORM_LIGHTS'
-            ];
-            // Scene feature flags and background selection are runtime uniforms so
-            // interactive edits do not recompile the path tracer.
-            const constantsNotUsed = [
-                ...Object.keys(WGPU_SCENE_FEATURE_BITS),
-                'USE_BACKGROUND',
-                'USE_BACKGROUND_MAP',
-                'USE_GROUNDED_BACKGROUND',
-                ...MATERIAL_TEXTURE_DEFINES,
-                'USE_ANISOTROPY_DIRECTIONS',
-                'USE_COAT_NORMAL_FRAMES',
-                'HAS_ALPHA_BLEND',
-                'HAS_ALPHA_MASK'
-            ];
-            const defines = definesKeys.reduce((obj, key) => {
-                obj[key] = constants[key];
-                return obj;
-            }, {});
-            const pipelineConstantsKeys = Object.keys(constants)
-                .sort()
-                .filter((key) => !definesKeys.includes(key) && !constantsNotUsed.includes(key));
-            const defineCode = definesKeys
-                .map((key) => `const ${key} = ${defines[key]};`)
-                .join('\n');
-            const previousPipelineConstantsKeys = Object.keys(this._prevPipelineConstants)
-                .filter((key) => !definesKeys.includes(key) && !constantsNotUsed.includes(key))
-                .sort();
-            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();
-                const constantsCode = pipelineConstantsKeys
-                    .map((key) => `${this._bakePipelineConstants ? 'const' : 'override'} ${key} = ${constants[key].toString()};`)
-                    .join('\n');
-                const rayTraceShaderCode = /* wgsl */ `
-${defineCode}
-${constantsCode}
-${rayTraceCompute({
-                    hasDisplacement: this._hasDisplacement,
+        };
+        const device = this._device, groupIndices = bindless ? [0, 1] : [0, 1, 2];
+        let startedAt = 0;
+        const compile = async () => {
+            startedAt = shaderCompilationNow();
+            // Override values are not part of the WGSL unless they are baked, so a
+            // quality edit can share the module that the driver has already parsed.
+            const moduleKey = JSON.stringify([causticKey, !!bindless, hasAlpha, hasSceneAlpha, hasDisplacement,
+                constants.USE_ANISOTROPY_DIRECTIONS, constants.USE_COAT_NORMAL_FRAMES, blasLayoutMask, defineCode, pipelineConstantsKeys,
+                bake && pipelineConstantsKeys.map((key) => constants[key])]);
+            let source = this._traceModules.get(moduleKey);
+            if (!source) {
+                let code = wgpuShaderSource(constants, {
+                    hasDisplacement,
                     hasAlpha,
                     hasSceneAlpha,
+                    ...transport?.features,
+                    lightTracing,
+                    photonMapping,
+                    photonMaxDepth: causticDiagnostics.photonMaxDepth ?? 20,
+                    photonDirectSubset: causticDiagnostics.photonDirectSubset,
+                    debugGroup: causticDiagnostics.debugGroup,
+                    workgroupSize: transport?.workgroupSize ?? WORKGROUP_SIZE,
                     hasAnisotropyDirections: Boolean(constants.USE_ANISOTROPY_DIRECTIONS),
                     hasCoatNormals: Boolean(constants.USE_COAT_NORMAL_FRAMES),
-                    blasLayoutMask: this._blasLayoutMask
-                })}`;
-                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,
+                    dynamicEnvironment: 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 = { ...this._constants };
-                this._prevDefinesCode = defineCode;
-                this._needsUpdateBindGroups = true;
-                device.pushErrorScope('validation');
-                let pipelineScopeOpen = true;
-                try {
-                    const pipelineConstants = !this._bakePipelineConstants
-                        ? pipelineConstantsKeys.reduce((obj, key) => {
-                            obj[key] = +this._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));
             }
-            // TODO rebind when lights, materials, bvh changed.
-            if (this._needsUpdateBindGroups) {
-                this._needsUpdateBindGroups = false;
-                this._updateBindGroups();
+            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;
+            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._failedPipelineSignature = undefined;
-        }
-        catch (error) {
-            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)
-                };
+            // 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._failedPipelineSignature = attemptedPipelineSignature;
-            // Do not allow the render loop to submit the previous/partial state.
-            // The failed signature prevents retrying the same shader every frame;
-            // changing a pipeline-affecting setting permits a new attempt.
-            this._rayTracePipeline = undefined;
-            this._rayTraceBindGroups = undefined;
-            this._prevPipelineConstants = {};
-            this._needsUpdateBindGroups = true;
+            variant.status = 'failed';
+            variant.error = error;
             console.error('Failed to update WebGPU ray tracing pipeline.', error);
+        });
+        variant.settled = new Promise((resolve) => {
+            this._queuedCompiles.push({ variant, signature, run, release: resolve });
+        });
+        this._traceVariants.set(signature, variant);
+        if (this._queuedCompiles.length > MAX_QUEUED_COMPILES) {
+            // A dropped variant stays pending, because a render that still wants it
+            // replaces it with a new request on its next frame.
+            const obsolete = this._queuedCompiles.shift();
+            if (this._traceVariants.get(obsolete.signature) === obsolete.variant)
+                this._traceVariants.delete(obsolete.signature);
+            obsolete.release();
+        }
+        for (const [key, retained] of this._traceVariants) {
+            if (this._traceVariants.size <= MAX_TRACE_VARIANTS)
+                break;
+            if (retained.status !== 'pending' && retained !== this._activeVariant)
+                this._traceVariants.delete(key);
+        }
+        this._pumpCompiles();
+        return variant;
+    }
+    /** Runs the most recently requested variants first: a dragged slider's last value is the one in use. */
+    _pumpCompiles() {
+        while (this._activeCompiles < MAX_CONCURRENT_COMPILES && this._queuedCompiles.length) {
+            const job = this._queuedCompiles.pop();
+            this._activeCompiles++;
+            void job.run().finally(() => {
+                this._activeCompiles--;
+                job.release();
+                if (!this._disposed)
+                    this._pumpCompiles();
+            });
         }
-        finally {
-            this._isCompilingShader = false;
+    }
+    _requestQueuedCompile(variant) {
+        const index = this._queuedCompiles.findIndex((job) => job.variant === variant);
+        if (index >= 0)
+            this._queuedCompiles.push(...this._queuedCompiles.splice(index, 1));
+    }
+    _prepareAovPipelines(kinds) {
+        const trace = this._rayTracePipeline;
+        if (!trace || !this._depthCompute)
+            return;
+        const reflectance = (aovMask(kinds) & 24) !== 0;
+        let variants = this._aovPipelines.get(trace);
+        if (!variants) {
+            variants = new Map();
+            this._aovPipelines.set(trace, variants);
+        }
+        let pipelines = variants.get(reflectance);
+        if (!pipelines) {
+            pipelines = {};
+            variants.set(reflectance, pipelines);
+            const pending = pipelines;
+            const textures = this._bindless, groupIndex = textures ? 2 : 3;
+            const output = this._device.createBindGroupLayout({ entries: [
+                    { binding: 5, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage' } },
+                    { binding: 6, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage' } },
+                    { binding: 7, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'read-only-storage' } },
+                    { binding: 8, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform' } },
+                    { binding: 9, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'read-only-storage' } }
+                ] });
+            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 } };
+            // 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; this._aovPipelinesFailed = true; });
+        }
+        if (pipelines.error)
+            throw pipelines.error;
+        return pipelines;
+    }
+    prepareAovs(kinds) {
+        const pipelines = this._prepareAovPipelines(kinds);
+        return !!pipelines?.accumulation && !!pipelines.center;
+    }
+    renderAovs(state, camera, samples, cap, kinds) {
+        const groups = this._rayTraceBindGroups;
+        if (!groups || !this._tlas || !this._preparedMeshData || !kinds.length)
+            return false;
+        const pipelines = this._prepareAovPipelines(kinds);
+        if (!pipelines?.accumulation || !pipelines.center)
+            return false;
+        state.resize(this._width, this._height);
+        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);
+            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));
+        const device = this._device;
+        const run = (pipeline, sample) => {
+            // A fresh uniform for each queued dispatch keeps batch samples independent.
+            const parameters = device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: true });
+            new Uint32Array(parameters.getMappedRange()).set([state.width, state.height, sample, aovMask(kinds)]);
+            parameters.unmap();
+            const output = device.createBindGroup({ layout: pipeline.getBindGroupLayout(groupIndex), entries: [
+                    { binding: 5, resource: { buffer: state.accumulation } }, { binding: 6, resource: { buffer: state.center } },
+                    { binding: 7, resource: { buffer: state.scene } }, { binding: 8, resource: { buffer: parameters } }, { binding: 9, resource: { buffer: state.previousCenter } }
+                ] });
+            const encoder = device.createCommandEncoder({ label: 'AOV' }), pass = encoder.beginComputePass();
+            if (textures?.table)
+                setResourceTable(pass, textures.table);
+            pass.setPipeline(pipeline);
+            for (let i = 0; i < groupIndex; i++)
+                pass.setBindGroup(i, groups[i]);
+            pass.setBindGroup(groupIndex, output);
+            pass.dispatchWorkgroups(Math.ceil(state.width / 8), Math.ceil(state.height / 8));
+            pass.end();
+            device.queue.submit([encoder.finish()]);
+            parameters.destroy();
+        };
+        if (!state.centerReady) {
+            run(pipelines.center, 0);
+            state.centerReady = true;
+            state.history.accept(state.frame);
+        }
+        if ((aovMask(kinds) & 31) === 0)
+            state.samples = target;
+        while (state.samples < target) {
+            run(pipelines.accumulation, state.samples);
+            state.samples++;
         }
+        return true;
     }
     async readDepthSamples(area, aspect) {
         const tracePipeline = this._rayTracePipeline;
         const groups = this._rayTraceBindGroups;
-        if (!tracePipeline || !groups || !this._depthCompute || this._isCompilingShader)
+        const textures = this._bindless, textureRevision = textures?.revision;
+        if (!tracePipeline || !groups || !this._depthCompute || this.isCompilingShader())
             return;
         const packed = packDepthSampleArea(area, aspect ?? this._width / this._height);
         if (this._depthTracePipeline !== tracePipeline || !this._depthPipeline) {
@@ -1071,10 +1059,11 @@ ${rayTraceCompute({
                     { binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform' } }
                 ]
             });
-            const layout = this._shaderCache.createPipelineLayout({
+            const descriptor = {
                 label: 'Depth query layout',
-                bindGroupLayouts: [0, 1, 2].map(i => tracePipeline.getBindGroupLayout(i)).concat(outputLayout)
-            });
+                bindGroupLayouts: (textures ? [0, 1] : [0, 1, 2]).map(i => tracePipeline.getBindGroupLayout(i)).concat(outputLayout)
+            };
+            const layout = this._shaderCache.createPipelineLayout(textures ? resourceTableLayout(descriptor) : descriptor);
             this._depthTracePipeline = tracePipeline;
             this._depthPipeline = this._shaderCache.createComputePipelineAsync({
                 label: 'Depth query', layout,
@@ -1084,7 +1073,7 @@ ${rayTraceCompute({
         }
         const pipeline = await this._depthPipeline;
         // Scene uploads can replace the buffers while the small query compiles.
-        if (tracePipeline !== this._rayTracePipeline || groups !== this._rayTraceBindGroups)
+        if (tracePipeline !== this._rayTracePipeline || groups !== this._rayTraceBindGroups || textures !== this._bindless || textureRevision !== textures?.revision)
             return;
         const device = this._device;
         const bytes = DEPTH_SAMPLE_COUNT * 16;
@@ -1096,16 +1085,18 @@ ${rayTraceCompute({
             usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
         try {
             device.queue.writeBuffer(params, 0, packed);
-            const outputGroup = device.createBindGroup({ layout: pipeline.getBindGroupLayout(3), entries: [
+            const outputGroup = device.createBindGroup({ layout: pipeline.getBindGroupLayout(textures ? 2 : 3), entries: [
                     { binding: 0, resource: { buffer: output } },
                     { binding: 4, resource: { buffer: params } }
                 ] });
             const encoder = device.createCommandEncoder({ label: 'Depth query' });
             const pass = encoder.beginComputePass();
+            if (textures?.table)
+                setResourceTable(pass, textures.table);
             pass.setPipeline(pipeline);
-            for (let i = 0; i < 3; i++)
+            for (let i = 0; i < (textures ? 2 : 3); i++)
                 pass.setBindGroup(i, groups[i]);
-            pass.setBindGroup(3, outputGroup);
+            pass.setBindGroup(textures ? 2 : 3, outputGroup);
             pass.dispatchWorkgroups(1);
             pass.end();
             encoder.copyBufferToBuffer(output, 0, readback, 0, bytes);
@@ -1121,15 +1112,17 @@ ${rayTraceCompute({
             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;
@@ -1140,50 +1133,66 @@ ${rayTraceCompute({
         if (!this._bvhBuffer || !this._instancesBuffer) {
             throw new Error('WebGPU BVH buffers are not ready.');
         }
-        const bufferBindGroup = _device.createBindGroup({
-            layout: bindGroupPipeline.getBindGroupLayout(0),
-            entries: [
-                this._bvhBuffer,
-                this._instancesBuffer,
-                this._attrBuffers,
-                this._materialsBuffer
-            ].map((buffer, i) => ({
-                binding: i,
-                resource: {
-                    buffer: buffer
-                }
-            }))
-        });
-        const texturesBindGroup = _device.createBindGroup({
-            layout: bindGroupPipeline.getBindGroupLayout(1),
-            entries: [
-                {
-                    binding: 0,
-                    resource: this._mapsSampler
-                },
-                {
-                    binding: 1,
-                    resource: this._maps.createView()
-                },
-                {
-                    binding: 3,
-                    resource: {
-                        buffer: this._mapInfoUniform
+        const bufferEntries = [
+            this._bvhBuffer,
+            this._instancesBuffer,
+            this._attrBuffers,
+            this._materialsBuffer
+        ].map((buffer, i) => ({
+            binding: i,
+            resource: {
+                buffer: buffer
+            }
+        }));
+        const textureEntries = [
+            ...(this._bindless
+                ? []
+                : [
+                    {
+                        binding: 0,
+                        resource: this._mapsSampler
+                    },
+                    {
+                        binding: 1,
+                        resource: this._maps.createView()
                     }
-                },
-                { binding: 4, resource: this._envTex.createView() },
-                { binding: 5, resource: this._envDistributionTex.createView() },
-                { binding: 6, resource: this._backgroundTex.createView() },
-                { binding: 8, resource: this._lightSamplingTexture.createView() },
-                { binding: 9, resource: this._openPbrEnergyLut.createView() },
-                {
-                    binding: 10,
-                    resource: this._adaptiveSamplingTexture.createView()
+                ]),
+            {
+                binding: 3,
+                resource: {
+                    buffer: this._bindless?.metadata ?? this._mapInfoUniform
                 }
-            ]
+            },
+            { 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() },
+            {
+                binding: 10,
+                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 uniformBindGroup = _device.createBindGroup({
-            layout: bindGroupPipeline.getBindGroupLayout(2),
+            layout: bindGroupPipeline.getBindGroupLayout(this._bindless ? 1 : 2),
             entries: Object.keys(this._uniforms).map((key, i) => ({
                 binding: i,
                 resource: {
@@ -1191,24 +1200,41 @@ ${rayTraceCompute({
                 }
             }))
         });
+        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(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 = [
             bufferBindGroup,
-            texturesBindGroup,
+            ...(texturesBindGroup ? [texturesBindGroup] : []),
             uniformBindGroup,
             outputBindGroup
         ];
@@ -1230,6 +1256,36 @@ ${rayTraceCompute({
             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) {
@@ -1240,6 +1296,8 @@ ${rayTraceCompute({
             };
         }
         const pass = encoder.beginComputePass(descriptor);
+        if (this._bindless?.table)
+            setResourceTable(pass, this._bindless.table);
         if (!this._rayTracePipeline || !this._rayTraceBindGroups) {
             throw new Error('WebGPU ray tracing pass was submitted before it was ready.');
         }
@@ -1247,8 +1305,32 @@ ${rayTraceCompute({
         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) {
@@ -1259,9 +1341,19 @@ ${rayTraceCompute({
         };
     }
     getDiagnostics() {
+        const atlas = this._materialData instanceof MaterialTable ? this._materialData.textureAtlasStats : undefined;
         return {
-            textureAtlas: this._materialData?.textureAtlasStats,
-            shaderCompilation: this._shaderCompilationDiagnostics,
+            textureAtlas: atlas,
+            materialTextures: {
+                requested: this._textureSelection.requested,
+                active: this._bindless ? 'bindless' : 'atlas',
+                fallbackReason: this._textureSelection.fallbackReason,
+                ...(this._bindless?.diagnostics ?? {
+                    textureCount: atlas?.textureCount ?? 0, estimatedBytes: atlas?.estimatedBytes ?? 0,
+                    scale: atlas?.scale ?? 1, metadataBytes: 0, resourceTableCapacity: 0, retiredBytes: 0
+                })
+            },
+            shaderCompilation: this._requestedVariant?.diagnostics,
             lightSampling: {
                 emissiveTriangles: this._emissiveTriangles.length,
                 activeChoices: this._rtUniform.views.lightChoiceCount[0],
@@ -1281,15 +1373,6 @@ ${rayTraceCompute({
         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() {
@@ -1325,15 +1408,14 @@ ${rayTraceCompute({
         return changed;
     }
     setSamplingPattern(pattern, maxSamples, sequenceSeed = 0) {
-        const code = samplingPatternCode(pattern);
-        const logSPP = zSobolLog2SPP(code === 1 ? maxSamples - 1 : maxSamples);
+        const sampling = traceSampling(pattern, maxSamples, sequenceSeed);
+        const { code, logSPP } = sampling;
         const views = this._rtUniform.views;
         const changed = this._constants.SAMPLING_PATTERN !== code ||
             views.sequenceSeed[0] !== (sequenceSeed >>> 0) ||
             (code === 1 && views.zSobolLogSPP[0] !== logSPP);
         this._constants.SAMPLING_PATTERN = code;
-        views.sequenceSeed[0] = sequenceSeed;
-        views.zSobolLogSPP[0] = logSPP;
+        writeTraceSampling(views, sampling);
         return changed;
     }
     setSampleSequenceOffset(offset) {
@@ -1354,10 +1436,27 @@ ${rayTraceCompute({
         this._device.queue.writeTexture({ texture: this._adaptiveSamplingTexture }, data, { bytesPerRow: width * Float32Array.BYTES_PER_ELEMENT }, [width, height]);
     }
     setQuality(options) {
-        this._rtUniform.views.bounces[0] = normalizeBounces(options.bounces);
-        this._rtUniform.views.bevel[0] = +options.bevel;
-        this._rtUniform.views.dispersionWavelengths[0] = options.dispersionWavelengths;
-        this._rtUniform.views.directLightCandidates[0] = normalizeDirectLightCandidates(options.directLightCandidates);
+        WGPURayTracePass.prototype._setCaustics.call(this, options.caustics);
+        writeTraceQuality(this._rtUniform.views, options);
+    }
+    _setCaustics(settings) {
+        this._causticSettings = settings;
+        const transport = researchTransport()?.configure(this, 'webgpu');
+        if (!!transport?.enabled !== !!this._transport?.enabled)
+            this._needsUpdateLightSamplingData = true;
+        this._transport = transport;
+        const hasCaster = !!(settings?.lightTracing || settings?.photonMapping) &&
+            this._meshes.some((mesh) => mesh.materials.some(isCausticSpecular));
+        const photonSupported = !(settings?.lightTracing || settings?.photonMapping) ||
+            !hasCaster ||
+            !hasStochasticCausticCaster(this._meshes);
+        this._lightTracing = !!settings?.lightTracing && hasCaster && photonSupported;
+        const photonMapping = !!settings?.photonMapping && hasCaster && photonSupported;
+        this._photonMapping = photonMapping;
+        this._causticKey =
+            this._transport?.enabled || this._lightTracing || this._photonMapping
+                ? `${this._lightTracing}/${this._photonMapping}/${causticDiagnostics.fullEmissionRandom !== false}/${causticDiagnostics.photonMaxDepth ?? 20}/${causticDiagnostics.debugGroup}/${causticDiagnostics.photonDirectSubset !== false}/${this._transport?.key ?? ''}`
+                : '';
     }
     _setEnvMap(envImage) {
         const device = this._device;
@@ -1365,53 +1464,74 @@ ${rayTraceCompute({
         if (!environmentMapSourcesMatch(envImage, this._envImageSource) ||
             !this._envTex) {
             this._envImageSource = envImage;
-            this._envTex?.destroy();
-            this._envDistributionTex?.destroy();
-            const distribution = envImage && envMapDistribution(envImage);
-            const usage = GPUTextureUsage.TEXTURE_BINDING |
-                GPUTextureUsage.COPY_DST |
-                GPUTextureUsage.RENDER_ATTACHMENT;
-            this._envTex = device.createTexture({
-                format: 'rgba32float',
-                usage,
-                label: 'Env',
-                size: {
-                    width: envImage ? envImage.width : 1,
-                    height: envImage ? envImage.height : 1,
-                    depthOrArrayLayers: 1
-                }
-            });
-            this._envDistributionTex = device.createTexture({
-                format: 'rg32float',
-                usage,
-                label: 'Env Distribution',
-                size: {
-                    width: distribution ? distribution.width : 1,
-                    height: distribution ? distribution.height : 1,
-                    depthOrArrayLayers: 1
-                }
-            });
-            if (envImage && distribution) {
-                device.queue.writeTexture({
-                    texture: this._envTex
-                }, envImage.data.buffer, {
-                    bytesPerRow: envImage.width * 4 * 4
-                }, {
-                    width: envImage.width,
-                    height: envImage.height,
-                    depthOrArrayLayers: 1
+            const sky = envImage && 'sky' in envImage ? envImage : undefined;
+            if (sky && (sky.width + 2 > device.limits.maxTextureDimension2D || sky.height + 1 > device.limits.maxTextureDimension2D))
+                throw new RangeError('ProceduralSky resolution exceeds the device texture size limit.');
+            const gpuDistribution = envImage && (sky || envImage.width * envImage.height >= 65536) &&
+                WGPUEnvMapDistribution.supported(device, envImage.width, envImage.height);
+            if (sky && !gpuDistribution)
+                throw new RangeError('ProceduralSky resolution exceeds the GPU sampling storage limit; reduce resolution.');
+            const distribution = envImage && !('sky' in envImage) && !gpuDistribution ? envMapDistribution(envImage) : undefined;
+            const distributionWidth = envImage ? envImage.width + 2 : 1;
+            const distributionHeight = envImage ? envImage.height + 1 : 1;
+            const width = envImage?.width ?? 1;
+            const height = envImage?.height ?? 1;
+            const resized = !this._envTex || this._envTex.width !== width || this._envTex.height !== height ||
+                !this._envDistributionTex || this._envDistributionTex.width !== distributionWidth || this._envDistributionTex.height !== distributionHeight;
+            if (resized) {
+                this._envTex?.destroy();
+                this._envDistributionTex?.destroy();
+                const usage = GPUTextureUsage.TEXTURE_BINDING |
+                    GPUTextureUsage.COPY_DST |
+                    GPUTextureUsage.RENDER_ATTACHMENT;
+                this._envTex = device.createTexture({
+                    format: 'rgba32float',
+                    usage: usage | GPUTextureUsage.STORAGE_BINDING,
+                    label: 'Env',
+                    size: {
+                        width,
+                        height,
+                        depthOrArrayLayers: 1
+                    }
                 });
-                device.queue.writeTexture({
-                    texture: this._envDistributionTex
-                }, distribution.data.buffer, {
-                    bytesPerRow: distribution.width * 4 * 2
-                }, {
-                    width: distribution.width,
-                    height: distribution.height,
-                    depthOrArrayLayers: 1
+                this._envDistributionTex = device.createTexture({
+                    format: 'rg32float',
+                    usage: usage | GPUTextureUsage.STORAGE_BINDING,
+                    label: 'Env Distribution',
+                    size: {
+                        width: distributionWidth,
+                        height: distributionHeight,
+                        depthOrArrayLayers: 1
+                    }
                 });
             }
-            this._needsUpdateBindGroups = true;
+            if (envImage) {
+                if ('sky' in envImage) {
+                    this._skyBaker ??= new WGPUSkyBaker(device);
+                    this._skyBaker.bake(envImage, this._envTex);
+                }
+                else
+                    device.queue.writeTexture({
+                        texture: this._envTex
+                    }, envImage.data.buffer, {
+                        bytesPerRow: envImage.width * 4 * 4
+                    }, {
+                        width: envImage.width,
+                        height: envImage.height,
+                        depthOrArrayLayers: 1
+                    });
+                if (gpuDistribution) {
+                    this._envDistribution ??= new WGPUEnvMapDistribution(device);
+                    this._envDistribution.build(this._envTex, this._envDistributionTex);
+                }
+                else if (distribution) {
+                    this._envDistribution?.dispose();
+                    device.queue.writeTexture({ texture: this._envDistributionTex }, distribution.data.buffer, { bytesPerRow: distribution.width * 4 * 2 }, { width: distribution.width, height: distribution.height, depthOrArrayLayers: 1 });
+                }
+            }
+            else
+                this._envDistribution?.dispose();
+            this._needsUpdateBindGroups ||= resized;
         }
         this._constants.USE_ENVMAP = !!envImage;
     }
@@ -1624,6 +1744,7 @@ ${rayTraceCompute({
     }
     setBackground(background) {
         this._rtUniform.views.backgroundMapTransform.set(backgroundMapTransform(background));
+        this._rtUniform.views.backgroundMapRotation.set(backgroundMapRotation(background));
         this._constants.USE_BACKGROUND = !!background;
         const backgroundImage = background && !Array.isArray(background)
             ? generateBackgroundMapFromSceneBackground(background)
@@ -1658,74 +1779,51 @@ ${rayTraceCompute({
             return;
         }
         this._backgroundImageSource = backgroundImage;
-        this._backgroundTex?.destroy();
         const width = backgroundImage?.width ?? 1;
         const height = backgroundImage?.height ?? 1;
-        this._backgroundTex = this._device.createTexture({
-            format: 'rgba32float',
-            usage: GPUTextureUsage.TEXTURE_BINDING |
-                GPUTextureUsage.COPY_DST |
-                GPUTextureUsage.RENDER_ATTACHMENT,
-            label: 'Background',
-            size: { width, height, depthOrArrayLayers: 1 }
-        });
-        if (backgroundImage) {
+        if (backgroundImage && 'sky' in backgroundImage && (width > this._device.limits.maxTextureDimension2D || height > this._device.limits.maxTextureDimension2D))
+            throw new RangeError('ProceduralSky resolution exceeds the device texture size limit.');
+        const resized = !this._backgroundTex || this._backgroundTex.width !== width || this._backgroundTex.height !== height;
+        if (resized) {
+            this._backgroundTex?.destroy();
+            this._backgroundTex = this._device.createTexture({
+                format: 'rgba32float',
+                usage: GPUTextureUsage.TEXTURE_BINDING |
+                    GPUTextureUsage.COPY_DST |
+                    GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
+                label: 'Background',
+                size: { width, height, depthOrArrayLayers: 1 }
+            });
+        }
+        if (backgroundImage && 'sky' in backgroundImage) {
+            this._skyBaker ??= new WGPUSkyBaker(this._device);
+            this._skyBaker.bake(backgroundImage, this._backgroundTex);
+        }
+        else if (backgroundImage) {
             const source = backgroundImage.data;
             const data = source instanceof Float32Array
                 ? source
-                : Float32Array.from(source, (value) => (source instanceof Uint8Array || source instanceof Uint8ClampedArray) ? value / 255 : value);
+                : source instanceof Uint8Array || source instanceof Uint8ClampedArray
+                    ? Float32Array.from(source, value => value / 255)
+                    : Float32Array.from(source);
             this._device.queue.writeTexture({ texture: this._backgroundTex }, data.buffer, { bytesPerRow: width * 4 * 4 }, { width, height, depthOrArrayLayers: 1 });
         }
-        this._needsUpdateBindGroups = true;
+        this._needsUpdateBindGroups ||= resized;
     }
     _updateLightSamplingData() {
-        const choices = this._lightChoices;
-        choices.reserve(1 + this._analyticLights.length + this._emissiveTriangles.length);
-        choices.push(LIGHT_CHOICE_ENVIRONMENT, 0, estimateEnvironmentPower(this._envImageSource));
-        this._analyticLights.forEach((light, i) => choices.push(LIGHT_CHOICE_ANALYTIC, i, estimateAnalyticLightPower(light)));
-        this._emissiveTriangles.forEach((triangle, i) => choices.push(LIGHT_CHOICE_EMISSIVE_TRIANGLE, i, triangle.area * triangle.samplingLuminance));
-        const distribution = buildLightAliasTable(choices);
-        const domainDiagnostics = {
-            environment: { count: 0, weight: 0, pmf: 0 },
-            infinite: { count: 0, weight: 0, pmf: 0 },
-            localAndEmissive: { count: 0, weight: 0, pmf: 0 }
-        };
-        this._analyticLightSelectionPmfs = new Array(this._analyticLights.length).fill(0);
-        this._rtUniform.views.envLightPmf[0] = 0;
-        const domains = [domainDiagnostics.environment, domainDiagnostics.infinite, domainDiagnostics.localAndEmissive];
-        for (let i = 0; i < choices.count; i++) {
-            const type = choices.sourceTypes[i], source = choices.sourceIndices[i];
-            const pmf = distribution.pmfs[i];
-            const domainIndex = type === LIGHT_CHOICE_ENVIRONMENT ? LIGHT_DOMAIN_ENVIRONMENT :
-                type === LIGHT_CHOICE_ANALYTIC && this._analyticLights[source]?.type === 'DirectionalLight' ?
-                    LIGHT_DOMAIN_INFINITE : LIGHT_DOMAIN_LOCAL_AND_EMISSIVE;
-            const domain = domains[domainIndex];
-            domain.count++;
-            domain.weight += choices.weights[i];
-            domain.pmf += pmf;
-            if (type === LIGHT_CHOICE_ENVIRONMENT)
-                this._rtUniform.views.envLightPmf[0] = pmf;
-            else if (type === LIGHT_CHOICE_ANALYTIC)
-                this._analyticLightSelectionPmfs[source] = pmf;
-            else
-                this._emissiveTriangles[source].selectionPmf = pmf;
-        }
-        this._lightDomainDiagnostics = domainDiagnostics;
-        this._rtUniform.views.lightChoiceCount[0] = choices.count;
-        this._rtUniform.views.lightWeightTotal[0] = distribution.totalWeight;
-        const emissiveTexels = this._emissiveTriangles.length * 6;
-        const choiceTexels = Math.max(choices.count, 1);
-        const profileStartTexel = emissiveTexels + choiceTexels;
-        const packedIES = packIESProfiles(this._analyticLights, profileStartTexel);
-        this._iesProfileTexelOffsets = packedIES.offsets;
-        const totalTexels = Math.max(profileStartTexel + packedIES.texelCount, 1);
-        const maxDimension = this._device.limits.maxTextureDimension2D;
-        const width = Math.min(maxDimension, Math.max(16, Math.ceil(Math.sqrt(totalTexels) / 16) * 16));
-        const height = Math.ceil(totalTexels / width);
-        if (height > maxDimension) {
-            throw new Error('Too many emissive triangles for the light sampling texture.');
-        }
-        const resized = !this._lightSamplingTexture || width !== this._lightSamplingTextureSize[0] || height !== this._lightSamplingTextureSize[1];
+        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];
         if (!this._lightSamplingTexture ||
             width !== this._lightSamplingTextureSize[0] ||
             height !== this._lightSamplingTextureSize[1]) {
@@ -1739,14 +1837,6 @@ ${rayTraceCompute({
             this._lightSamplingTextureSize = [width, height];
             this._needsUpdateBindGroups = true;
         }
-        const textureData = this._lightSamplingScratch?.length === width * height * 4
-            ? this._lightSamplingScratch : new Float32Array(width * height * 4);
-        textureData.fill(0);
-        if (this._emissiveTriangles.length) {
-            packEmissiveTriangles(this._emissiveTriangles, textureData);
-        }
-        new Uint32Array(textureData.buffer).set(distribution.choices, emissiveTexels * 4);
-        textureData.set(packedIES.data, profileStartTexel * 4);
         const previous = this._lightSamplingData;
         const full = resized || !previous || this._lightSamplingTriangleCount !== this._emissiveTriangles.length;
         const words = new Uint32Array(textureData.buffer);
@@ -1772,8 +1862,6 @@ ${rayTraceCompute({
         this._lightSamplingScratch = previous;
         this._lightSamplingData = textureData;
         this._lightSamplingTriangleCount = this._emissiveTriangles.length;
-        this._rtUniform.views.lightSamplingTextureWidth[0] = width;
-        this._rtUniform.views.lightChoiceTexelOffset[0] = emissiveTexels;
         this._needsUpdateAnalyticLightsBuffer = true;
         this._needsUpdateLightSamplingData = false;
     }
@@ -1823,33 +1911,15 @@ ${rayTraceCompute({
         const tlas = buildTLAS(res.instances, res.blases);
         this._tlas = tlas;
         this._uploadBVH(tlas, res.blases);
-        const materialData = (this._materialData = new MaterialTable(materials, this._analyticLights, {
+        const materialData = (this._materialData = this._createMaterialData(materials, this._analyticLights, {
             maxTextureArrayBytes: this._maxTextureArrayBytes,
             maxTextureArrayLayers: this._device.limits.maxTextureArrayLayers,
             maxTextureDimension2D: this._device.limits.maxTextureDimension2D
         }));
         this._emissiveTriangles = this._emissiveCache.collect(res.emissiveBindings, materials);
         this._needsUpdateLightSamplingData = true;
-        const attrNames = [
-            'position',
-            'normal',
-            'uv',
-            'uv1',
-            'color',
-            'tangent',
-            'materialIndex'
-        ];
-        const attributes = attrNames.map((a) => mergedGeometry[a]);
-        const fixedSize = 4;
-        let stride = 0;
-        const offsets = attrNames.map((attrName, idx) => {
-            const attr = attributes[idx];
-            const offset = stride;
-            if (attr) {
-                stride += fixedSize;
-            }
-            return offset;
-        });
+        const attributeLayout = sceneAttributeLayout(mergedGeometry);
+        const { stride, offsets } = attributeLayout;
         const attrBufferData = new F32(mergedGeometry.vertexCount * stride);
         packVertexAttributes(mergedGeometry, attrBufferData, stride, offsets, 0, mergedGeometry.vertexCount);
         this._attributeData = attrBufferData;
@@ -1869,17 +1939,7 @@ ${rayTraceCompute({
             cwbvh: 8
         };
         this._blasLayoutMask = res.blases.reduce((mask, blas) => mask | blasLayoutBits[blas.bvh.layout ?? 'bvh2'], 0);
-        Object.assign(this._constants, {
-            TLAS_STACK_SIZE: retainedShaderCapacity(traversalStackSizes.tlas, Number(this._constants.TLAS_STACK_SIZE ?? 0)),
-            BLAS_STACK_SIZE: retainedShaderCapacity(traversalStackSizes.blas, Number(this._constants.BLAS_STACK_SIZE ?? 0), 32),
-            USE_UV: mergedGeometry.uv != null,
-            USE_VERTEX_COLOR: mergedGeometry.color != null,
-            ATTR_STRIDE: stride / fixedSize,
-            ...offsets.reduce((obj, off, idx) => {
-                obj[attrNames[idx].toUpperCase() + '_OFF'] = off / fixedSize;
-                return obj;
-            }, {})
-        });
+        Object.assign(this._constants, sceneTraversalConstants(traversalStackSizes.tlas, traversalStackSizes.blas, this._constants), attributeLayout.constants);
         this._updateMaterialConstants(materials, materialData, mergedGeometry);
         this._updateTextures(materialData);
         this._needsUpdateBindGroups = true;
@@ -1905,52 +1965,11 @@ ${rayTraceCompute({
         }
         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;
-        }
-        const HAS_BEVEL = materials.some((m) => m.bevelSize > 0);
-        const SPECTRAL = materials.some((m) => m.transmissionDispersionScale > 0);
-        const HAS_MEDIUM = materials.some(materialUsesMedium);
-        // Retain the atlas uniform capacity when a stage/material is removed.
-        // Shrinking the array would rebuild every pipeline again on the next edit.
-        const NUM_MAPS = Math.max(Math.ceil(+materialData.defines.NUM_MAPS / 10) * 10, Number(this._constants.NUM_MAPS ?? 0), 20);
-        // Either layer's map requires independent normals, including a smooth
-        // coat over a mapped base. Unmapped materials retain the shared path.
-        const USE_COAT_NORMAL_FRAMES = materials.some(m => m.coatWeight > 0 && (!!m.normalMap || !!m.coatNormalMap));
-        Object.assign(this._constants, {
-            // Match the atlas UV selector. Keep the second set when any texture
-            // needs it; material/texture edits already rebuild these constants.
-            USE_UV1: materialData.bufferData.mapUvChannel.some(channel => channel > 0.5),
-            // Isotropic OpenPBR constructs its own basis. Normal mapping uses
-            // triangle UV differentials rather than this vertex tangent.
-            USE_TANGENT: mergedGeometry.tangent != null &&
-                materials.some(material => material.specularAnisotropy > 0 || material.coatAnisotropy > 0 || (!!material.coatNormalMap && material.coatWeight > 0)),
-            USE_COAT_NORMAL_FRAMES,
-            USE_ANISOTROPY_DIRECTIONS: USE_COAT_NORMAL_FRAMES || materials.some(m => m.specularAnisotropy > 0 && (m.specularAnisotropyModel === 'gltf' || !!m.anisotropyMap || m.specularAnisotropyRotation !== 0) ||
-                m.coatAnisotropy > 0 && m.coatAnisotropyRotation !== 0),
-            HAS_MEDIUM,
-            HAS_SHADOW_CATCHER: this._hasShadowCatcher,
-            HAS_THIN_FILM: materials.some((material) => material.thinFilmWeight > 0),
-            HAS_COAT: materials.some((material) => material.coatWeight > 0),
-            HAS_FUZZ: materials.some((material) => material.fuzzWeight > 0),
-            HAS_SUBSURFACE: materials.some((material) => material.subsurfaceWeight > 0),
-            HAS_BEVEL,
-            HAS_ALPHA_MASK: materials.some((m) => resolveMaterialAlphaMode(m) === 'mask'),
-            HAS_ALPHA_BLEND: materials.some((m) => resolveMaterialAlphaMode(m) === 'blend'),
-            HAS_ALPHA: materials.some((m) => resolveMaterialAlphaMode(m) !== 'opaque'),
-            SPECTRAL,
-            BEVEL_SAMPLES: this._bevelSamples,
-            USE_RR: true,
-            // Match WebGL: defer roulette for multiple-scattering SSS paths.
-            RR_MAX: HAS_MEDIUM ? 12 : 2,
-            NUM_UNIFORM_LIGHTS: FIXED_LIGHT_COUNT,
-            ...materialData.defines,
-            NUM_MAPS,
-            ...materialTextureFeatures(materialData.defines),
-            USE_NORMAL_MAPS: +materialData.defines.NUM_NORMAL_MAPS > 0
-        });
+        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;
     }
     _updateGeometryData() {
         const res = this._preparedMeshData, tlas = this._tlas;
@@ -1996,7 +2015,7 @@ ${rayTraceCompute({
         const res = this._preparedMeshData;
         let materialData = this._materialData;
         if (update.level === 'textures') {
-            materialData = this._materialData = new MaterialTable(res.materials, this._analyticLights, {
+            materialData = this._materialData = this._createMaterialData(res.materials, this._analyticLights, {
                 maxTextureArrayBytes: this._maxTextureArrayBytes,
                 maxTextureArrayLayers: this._device.limits.maxTextureArrayLayers,
                 maxTextureDimension2D: this._device.limits.maxTextureDimension2D
@@ -2106,7 +2125,26 @@ ${rayTraceCompute({
         this._dirtyTransformMeshes.clear();
         this._needsRefitTLAS = false;
     }
+    _createMaterialData(...args) {
+        if (this._bindless) {
+            const data = new WGPUBindlessMaterialData(args[0], args[1]);
+            const reason = bindlessLimitReason(this._device, data.textures.length);
+            if (!reason)
+                return data;
+            this._textureSelection.fallbackReason = reason;
+            const retired = this._bindless;
+            this._retiredBindless.add(retired);
+            void this._device.queue.onSubmittedWorkDone().catch(() => { }).then(() => { retired.dispose(); this._retiredBindless.delete(retired); });
+            this._bindless = undefined;
+        }
+        return new MaterialTable(...args);
+    }
     _updateTextures(materialData) {
+        if (materialData instanceof WGPUBindlessMaterialData) {
+            this._bindless.update(materialData.textures, this._maxTextureArrayBytes);
+            this._needsUpdateBindGroups = true;
+            return;
+        }
         // Textures
         // TODO Avoid zero length array.
         const mapInfo = materialData.bufferData.mapInfo ?? [0, 0, 0, 0];
@@ -2209,6 +2247,10 @@ ${rayTraceCompute({
     }
     // 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;
@@ -2268,14 +2310,7 @@ ${rayTraceCompute({
         const arr = this._rtUniform.views.jitter;
         arr[0] = x;
         arr[1] = y;
-        this._device.queue.writeBuffer(this._uniforms.cameraUniform, 0, new F32([
-            ...this._viewProjInv,
-            ...this._cameraWorld,
-            this._apertureRadius,
-            this._focusDistance,
-            0,
-            0
-        ]));
+        this._device.queue.writeBuffer(this._uniforms.cameraUniform, 0, packCameraUniform(this._viewProjInv, this._cameraWorld, this._apertureRadius, this._focusDistance));
     }
     setSampleTiles(columns, rows, tileX, tileY) {
         const arr = this._rtUniform.views.scaleOffset;
@@ -2301,9 +2336,18 @@ ${rayTraceCompute({
         return this._hasShadowCatcher;
     }
     dispose() {
+        this._disposed = true;
+        this._envDistribution?.dispose();
+        this._skyBaker?.dispose();
+        this._bindless?.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,
@@ -2323,6 +2367,9 @@ ${rayTraceCompute({
             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;
     }