@meimu/mutracer 0.2.0 → 0.3.1

package/lib/renderer/WebGLRayTracePass.d.ts

@@ -1,3 +1,4 @@
+import { type SurfaceHit } from './surfaceHit.js';
 import { WebGLAov } from './WebGLAov.js';
 import { type AovKind } from './aov.js';
 import { type SamplingPattern } from './sampling.js';
@@ -12,6 +13,10 @@ declare class WebGLRayTracePass {
     private _aovPrimitiveCache;
     private readonly _renderer;
     private _meshes;
+    private _emissiveActive;
+    private _directLightLegacy?;
+    private _emissiveCache;
+    private _emissiveTex;
     private _sceneEnvironment;
     private _rectLightTextures;
     private _analyticLights;
@@ -33,8 +38,9 @@ declare class WebGLRayTracePass {
     private _dirtyColorMeshes;
     private _tlas?;
     private _bvhData?;
-    private _instancesData?;
-    private _materialIndexData?;
+    private _instancesOffset;
+    private _vertexAttributeData?;
+    private _vertexAttributeLayout?;
     private _meshSnapshot;
     private _snapshotByMesh;
     private _needsUpdateAnalyticLightsBuffer;
@@ -62,14 +68,8 @@ declare class WebGLRayTracePass {
     private _sequenceSeed;
     private _zLogSPP;
     private _positionBufferTex;
-    private _normalBufferTex;
-    private _colorBufferTex;
-    private _tangentBufferTex;
-    private _uvBufferTex;
-    private _uv1BufferTex;
+    private _vertexAttributeTex;
     private _bvhBufferTex;
-    private _instancesBufferTex;
-    private _matIndexBufferTex;
     private _hasTransmission;
     private _hasAlpha;
     private _invalid;
@@ -77,6 +77,7 @@ declare class WebGLRayTracePass {
     private _mainPass;
     private _shadowCatcherPass;
     private _viewProjInv;
+    private _projectionInv;
     private _apertureRadius;
     private _focusDistance;
     private _aovPass;
@@ -87,6 +88,8 @@ declare class WebGLRayTracePass {
     private _depthAspect;
     private _hasShadowCatcher;
     private _spectral;
+    private _shareSpectralPrefix;
+    private _independentSpectralPaths;
     constructor(renderer: WebGLRenderer);
     preparePrograms(): boolean;
     createPass(clear: boolean, tile: {
@@ -116,6 +119,8 @@ declare class WebGLRayTracePass {
         textureAtlas: import("./textureAtlas.js").TextureAtlasStats | undefined;
     };
     private _updateMeshData;
+    private _uploadBVH;
+    private _uploadInstanceRanges;
     private _updateMaterialConstants;
     private _updateMeshMembership;
     private _updateGeometryData;
@@ -136,18 +141,22 @@ declare class WebGLRayTracePass {
         bevel: boolean;
         dispersionWavelengths: 1 | 3;
         directLightCandidates: number;
+        caustics?: import('../Render.js').CausticSettings;
     }): void;
-    setWavelength(wavelength: number): void;
+    setSpectralChannel(channel: number): void;
     setSampleCount(sampleCount: number): void;
     isInvalid(): boolean;
     hasShadowCatcher(): boolean;
     hasDispersion(): boolean;
+    hasSharedSpectralPrefix(): boolean;
     prepare(): void;
     setSamplingPattern(pattern: SamplingPattern, maxSamples: number, sequenceSeed?: number): boolean;
     setSampleSequenceOffset(_offset: number): void;
     prepareAovs(state: WebGLAov, camera: Camera, width: number, height: number, kinds: readonly AovKind[]): boolean;
     renderAovs(state: WebGLAov, camera: Camera, width: number, height: number, samples: number, cap: number, kinds: readonly AovKind[], sequenceOffset?: number): boolean;
-    readDepthSamples(area: DepthSampleArea, aspect?: number): Promise<Float32Array | undefined>;
+    pickSurface(x: number, y: number, aspect?: number): Promise<SurfaceHit | null | undefined>;
+    readDepthSamples(area: DepthSampleArea, aspect?: number): Promise<Float32Array<ArrayBufferLike> | undefined>;
+    private _readDepthSamples;
     dispose(): void;
 }
 export default WebGLRayTracePass;

package/lib/renderer/WebGLRayTracePass.js

@@ -1,9 +1,14 @@
+import { materialNeedsVertexTangents } from './tangentRequirements.js';
+import { resolveSurfaceHit } from './surfaceHit.js';
+import { researchTransport } from './researchTransport.js';
+import { EmissiveTriangleCache } from './lightSampling.js';
+import { prepareWebGLLightSampling } from './webglLightSampling.js';
 import { AovPrimitiveCache } from './AovPrimitiveCache.js';
 import { aovTraceFragment } from './glsl/aovTrace.frag.js';
 import { packAovScene } from './aovScene.js';
-import { aovMask } from './aov.js';
+import { aovMask, AOV_ACCUMULATED_MASK, AOV_REFLECTANCE_MASK } from './aov.js';
 import { WebGLSkySource } from './WebGLSkySource.js';
-import { normalizeBounces } from './pathLimits.js';
+import { normalizeBounces, MAX_PATH_EVENTS_WEBGL } from './pathLimits.js';
 import { updateMeshInstanceColors } from './prepareMeshBVH.js';
 import { updateTLASInstanceColors } from './bvhAccel.js';
 import { getMaterialHashKey } from '../scene/openPbrSchema.js';
@@ -22,7 +27,7 @@ import { MaterialChangeTracker, materialIsEmissive } from './materialChanges.js'
 import { constants, Texture2D as WebGLTexture2D } from './webgl.js';
 import { WebGLFullQuadPass } from './WebGLFullQuadPass.js';
 import { mat4 } from '../math.js';
-import { buildBLAS, buildTLAS, concatBLASBuffers, refitBLAS, refitTLAS, mergeRefitRanges } from './bvhAccel.js';
+import { buildBLAS, buildWebTLAS, concatBLASBuffers, refitBLAS, refitTLAS, mergeRefitRanges } from './bvhAccel.js';
 import { generateBackgroundMapFromSceneBackground, environmentRotation, backgroundMapTransform, backgroundMapRotation } from './envMapCreation.js';
 import { envMapDistribution, environmentMapSourcesMatch } from './envMapDistribution.js';
 import createRayTraceFragmentShader from './glsl/rayTrace.frag.js';
@@ -37,6 +42,7 @@ import { updatePreparedGeometries, canUpdateGeometries, geometryTopologyChanged
 import { Attribute } from '../scene/Geometry.js';
 import { updateMeshInstances, updateMeshInstanceTransforms } from './prepareMeshBVH.js';
 import { mergeMeshesToGeometry } from './mergeMeshesToGeometry.js';
+import { packVertexAttributes, vertexAttributeDefines, vertexAttributeLayout } from './webglVertexAttributes.js';
 import { DEFAULT_BEVEL_SAMPLES, normalizeBevelSamples } from './RenderingPipeline.js';
 import { getOpenPbrEnergyLutData, OPENPBR_ENERGY_LUT_HEIGHT, OPENPBR_ENERGY_LUT_WIDTH } from './openPbrEnergyLut.js';
 // A defensive mixture keeps weak-but-wide lights from being starved by an
@@ -64,6 +70,10 @@ class WebGLRayTracePass {
     _aovPrimitiveCache = new AovPrimitiveCache();
     _renderer;
     _meshes = [];
+    _emissiveActive = false;
+    _directLightLegacy;
+    _emissiveCache = new EmissiveTriangleCache();
+    _emissiveTex = new WebGLTexture2D(commonNearestFloatProps);
     _sceneEnvironment = new SceneEnvironmentCache();
     _rectLightTextures = new RectLightTextureTracker();
     _analyticLights = [];
@@ -85,8 +95,9 @@ class WebGLRayTracePass {
     _dirtyColorMeshes = new Set();
     _tlas;
     _bvhData;
-    _instancesData;
-    _materialIndexData;
+    _instancesOffset = 0;
+    _vertexAttributeData;
+    _vertexAttributeLayout;
     _meshSnapshot = [];
     _snapshotByMesh = new WeakMap();
     _needsUpdateAnalyticLightsBuffer = true;
@@ -122,17 +133,8 @@ class WebGLRayTracePass {
     _sequenceSeed = 0;
     _zLogSPP = 0;
     _positionBufferTex = new WebGLTexture2D(commonNearestFloatProps);
-    _normalBufferTex = new WebGLTexture2D(commonNearestFloatProps);
-    _colorBufferTex = new WebGLTexture2D(commonNearestFloatProps);
-    _tangentBufferTex = new WebGLTexture2D(commonNearestFloatProps);
-    _uvBufferTex = new WebGLTexture2D(commonNearestFloatProps);
-    _uv1BufferTex = new WebGLTexture2D(commonNearestFloatProps);
+    _vertexAttributeTex = new WebGLTexture2D(commonNearestFloatProps);
     _bvhBufferTex = new WebGLTexture2D(commonNearestFloatProps);
-    _instancesBufferTex = new WebGLTexture2D(commonNearestFloatProps);
-    _matIndexBufferTex = new WebGLTexture2D({
-        ...commonNearestFloatProps
-        // type: constants.INT
-    });
     _hasTransmission = false;
     _hasAlpha = false;
     _invalid = false;
@@ -140,6 +142,7 @@ class WebGLRayTracePass {
     _mainPass;
     _shadowCatcherPass;
     _viewProjInv = mat4.create();
+    _projectionInv = mat4.create();
     _apertureRadius = 0;
     _focusDistance = 10;
     _aovPass;
@@ -150,6 +153,8 @@ class WebGLRayTracePass {
     _depthAspect = 1;
     _hasShadowCatcher = false;
     _spectral = false;
+    _shareSpectralPrefix = true;
+    _independentSpectralPaths = false;
     constructor(renderer) {
         this._renderer = renderer;
         const accumulationOutput = {
@@ -222,7 +227,7 @@ class WebGLRayTracePass {
             : this._mainPass.getOutput(label);
     }
     setBounce(bounce) {
-        const next = normalizeBounces(bounce);
+        const next = normalizeBounces(bounce, MAX_PATH_EVENTS_WEBGL);
         const changed = this._bounces !== next;
         this._bounces = next;
         return changed;
@@ -433,34 +438,14 @@ class WebGLRayTracePass {
         this._needsUpdateMeshMembership = false;
         const mergedGeometry = res.geometry;
         const materials = res.materials;
-        const tlas = buildTLAS(res.instances, res.blases);
-        this._tlas = tlas;
-        const tlasBuffer = new Float32Array(tlas.buffer);
-        const instancesBuffer = this._instancesData = new Float32Array(tlas.instancesBuffer);
-        const blasBuffer = new Float32Array(concatBLASBuffers(res.blases));
-        const bvhBuffer = this._bvhData = new Float32Array(tlasBuffer.length + blasBuffer.length);
-        const blasOffset = tlasBuffer.length / 4;
-        bvhBuffer.set(tlasBuffer);
-        bvhBuffer.set(blasBuffer, blasOffset * 4);
+        this._tlas = buildWebTLAS(res.instances, res.blases);
+        this._uploadBVH(new Float32Array(concatBLASBuffers(res.blases)));
+        const layout = this._vertexAttributeLayout = vertexAttributeLayout(mergedGeometry);
+        let vertexAttributeColumns = 0;
         if (mergedGeometry.position.array.length > 0) {
             setDataTexture(this._positionBufferTex, mergedGeometry.position.array, 3);
-            setDataTexture(this._normalBufferTex, mergedGeometry.normal.array, 3);
-            mergedGeometry.color &&
-                setDataTexture(this._colorBufferTex, mergedGeometry.color.array, 3);
-            mergedGeometry.tangent &&
-                setDataTexture(this._tangentBufferTex, mergedGeometry.tangent.array, 4);
-            mergedGeometry.uv &&
-                setDataTexture(this._uvBufferTex, mergedGeometry.uv.array, 2);
-            mergedGeometry.uv1 &&
-                setDataTexture(this._uv1BufferTex, mergedGeometry.uv1.array, 2);
-            mergedGeometry.materialIndex &&
-                setDataTexture(this._matIndexBufferTex, 
-                // TODO currently int texture doesn't work
-                this._materialIndexData = new Float32Array(mergedGeometry.materialIndex.array), 4);
-        }
-        if (bvhBuffer.length > 0) {
-            setDataTexture(this._bvhBufferTex, bvhBuffer, 4);
-            setDataTexture(this._instancesBufferTex, instancesBuffer, 4);
+            this._vertexAttributeData = packVertexAttributes(mergedGeometry, layout, new Float32Array(mergedGeometry.vertexCount * layout.stride * 4));
+            vertexAttributeColumns = setDataTexture(this._vertexAttributeTex, this._vertexAttributeData, 4).columnsLog;
         }
         this._materialData?.dispose(this._renderer.gl);
         const materialData = new MaterialTable(materials, this._analyticLights, {
@@ -472,26 +457,41 @@ class WebGLRayTracePass {
         this._tracePasses.forEach((pass) => {
             pass.setUniforms({
                 bvhBuffer: this._bvhBufferTex,
-                instancesBuffer: this._instancesBufferTex,
                 positionBuffer: this._positionBufferTex,
-                normalBuffer: this._normalBufferTex,
-                tangentBuffer: mergedGeometry.tangent ? this._tangentBufferTex : null,
-                colorBuffer: mergedGeometry.color ? this._colorBufferTex : null,
-                uvBuffer: mergedGeometry.uv ? this._uvBufferTex : null,
-                uv1Buffer: mergedGeometry.uv1 ? this._uv1BufferTex : null,
-                materialIndexBuffer: this._matIndexBufferTex,
-                bvhColumns: textureDimensionsFromArray(bvhBuffer.length / 4).columnsLog,
+                vertexAttributes: this._vertexAttributeTex,
                 vertexColumns: textureDimensionsFromArray(Attribute.getCount(mergedGeometry.position)).columnsLog,
-                instancesColumns: textureDimensionsFromArray(instancesBuffer.length / 4)
-                    .columnsLog,
-                blasOffset,
+                vertexAttributeColumns,
                 isEmptyScene: +(res.instances.length === 0)
             });
         });
         this._updateMaterialConstants(materials, materialData, mergedGeometry);
         this._materialChanges.capture(materials);
         this._pendingMaterialUpdate = undefined;
-        return bvhBuffer;
+    }
+    // One texture holds the TLAS, the BLASes and then the instance records.
+    _uploadBVH(blas) {
+        const tlas = this._tlas, instances = new Float32Array(tlas.instancesBuffer);
+        const tlasLength = tlas.buffer.byteLength / 4, instancesOffset = tlasLength + blas.length;
+        const data = this._bvhData = new Float32Array(instancesOffset + instances.length);
+        data.set(new Float32Array(tlas.buffer));
+        data.set(blas, tlasLength);
+        data.set(instances, instancesOffset);
+        this._instancesOffset = instancesOffset / 4;
+        if (data.length > 0)
+            setDataTexture(this._bvhBufferTex, data, 4);
+        this._tracePasses.forEach(pass => pass.setUniforms({
+            bvhColumns: textureDimensionsFromArray(data.length / 4).columnsLog,
+            blasOffset: tlasLength / 4,
+            instancesOffset: this._instancesOffset
+        }));
+    }
+    _uploadInstanceRanges(ranges) {
+        const instances = new Uint8Array(this._tlas.instancesBuffer), data = this._bvhData;
+        const base = this._instancesOffset * 16;
+        for (const { offset, size } of ranges) {
+            new Uint8Array(data.buffer).set(instances.subarray(offset, offset + size), base + offset);
+            this._bvhBufferTex.updateDataRange(this._renderer.gl, data, base + offset, size);
+        }
     }
     _updateMaterialConstants(materials, materialData, mergedGeometry) {
         // Avoid too much shader compilation
@@ -503,13 +503,24 @@ class WebGLRayTracePass {
         this._hasTransmission = materials.some((m) => m.transmissionWeight > 0 ||
             m.mapAlphaUsage === "transmission");
         this._hasAlpha = materials.some((m) => resolveMaterialAlphaMode(m) !== 'opaque');
-        this._spectral = materials.some((m) => m.transmissionDispersionScale > 0);
+        const spectral = materials.some((m) => m.transmissionDispersionScale > 0);
+        if (spectral !== !!this._spectral) {
+            this._spectral = spectral;
+            const shader = createRayTraceFragmentShader({
+                channelIndependentLight: spectral, shareSpectralPrefix: spectral && this._shareSpectralPrefix
+            });
+            if (!researchTransport()?.configure(this, 'webgl')?.enabled) {
+                shader.parallelCompile = true;
+                this._mainPass.setShader(shader);
+            }
+        }
         this._tracePasses.forEach(pass => {
             pass.setDefines({
                 OES_texture_float_linear: true,
                 STACK_SIZE,
                 USE_VERTEX_COLOR: mergedGeometry.color != null,
-                USE_TANGENT: mergedGeometry.tangent != null,
+                USE_TANGENT: mergedGeometry.tangent != null && materials.some(materialNeedsVertexTangents),
+                ...vertexAttributeDefines(vertexAttributeLayout(mergedGeometry)),
                 USE_COAT_NORMAL_FRAMES: materials.some(m => m.coatWeight > 0 && (!!m.normalMap || !!m.coatNormalMap)),
                 HAS_TRANSMISSION: this._hasTransmission,
                 HAS_GLTF_ANISOTROPY: materials.some(m => m.specularAnisotropyModel === 'gltf' && m.specularAnisotropy > 0),
@@ -524,7 +535,7 @@ class WebGLRayTracePass {
                 // Multiple-scattering SSS paths need enough collisions to return to
                 // the boundary before roulette; terminating at depth five produces
                 // dark materials and a handful of very large surviving samples.
-                RR_MAX: HAS_MEDIUM ? 12 : 2,
+                RR_MAX: 12,
                 ...materialData.defines
             });
             materialData.setToPass(pass);
@@ -533,20 +544,9 @@ class WebGLRayTracePass {
     _updateMeshMembership() {
         const res = this._pendingMembershipData;
         this._preparedMeshData = res;
-        const tlas = this._tlas = buildTLAS(res.instances, res.blases);
-        const blas = new Float32Array(concatBLASBuffers(res.blases));
-        const data = this._bvhData = new Float32Array(tlas.buffer.byteLength / 4 + blas.length);
-        data.set(new Float32Array(tlas.buffer));
-        data.set(blas, tlas.buffer.byteLength / 4);
-        this._instancesData = new Float32Array(tlas.instancesBuffer);
-        setDataTexture(this._bvhBufferTex, data, 4);
-        setDataTexture(this._instancesBufferTex, this._instancesData, 4);
-        this._tracePasses.forEach(pass => pass.setUniforms({
-            bvhColumns: textureDimensionsFromArray(data.length / 4).columnsLog,
-            instancesColumns: textureDimensionsFromArray(this._instancesData.length / 4).columnsLog,
-            blasOffset: tlas.buffer.byteLength / 16,
-            isEmptyScene: +(res.instances.length === 0)
-        }));
+        this._tlas = buildWebTLAS(res.instances, res.blases);
+        this._uploadBVH(new Float32Array(concatBLASBuffers(res.blases)));
+        this._tracePasses.forEach(pass => pass.setUniform('isEmptyScene', +(res.instances.length === 0)));
         this._pendingMembershipData = undefined;
         this._needsUpdateMeshMembership = false;
         this._debugBvhData = undefined;
@@ -554,20 +554,12 @@ class WebGLRayTracePass {
     _updateGeometryData() {
         const res = this._preparedMeshData, tlas = this._tlas;
         const update = updatePreparedGeometries(res, this._pendingGeometryUpdates);
-        for (const { first, count, topologyChanged, deformationOnly } of update.vertices) {
-            for (const [attribute, texture] of [
-                [res.geometry.position, this._positionBufferTex], [res.geometry.normal, this._normalBufferTex],
-                [res.geometry.tangent, this._tangentBufferTex], [res.geometry.color, this._colorBufferTex],
-                [res.geometry.uv, this._uvBufferTex], [res.geometry.uv1, this._uv1BufferTex]
-            ])
-                if (attribute && (!deformationOnly || attribute === res.geometry.position || attribute === res.geometry.normal || attribute === res.geometry.tangent))
-                    texture.updateDataRange(this._renderer.gl, attribute.array, first * attribute.itemSize * 4, count * attribute.itemSize * 4);
-            if (!topologyChanged)
-                continue;
-            const material = this._materialIndexData;
-            for (let i = first * 4; i < (first + count) * 4; i++)
-                material[i] = res.geometry.materialIndex.array[i];
-            this._matIndexBufferTex.updateDataRange(this._renderer.gl, material, first * 16, count * 16);
+        const layout = this._vertexAttributeLayout, attributes = this._vertexAttributeData;
+        for (const { first, count } of update.vertices) {
+            const position = res.geometry.position;
+            this._positionBufferTex.updateDataRange(this._renderer.gl, position.array, first * position.itemSize * 4, count * position.itemSize * 4);
+            packVertexAttributes(res.geometry, layout, attributes, first, count);
+            this._vertexAttributeTex.updateDataRange(this._renderer.gl, attributes, first * layout.stride * 16, count * layout.stride * 16);
         }
         for (const mesh of update.meshes)
             this._dirtyTransformMeshes.add(mesh);
@@ -577,12 +569,7 @@ class WebGLRayTracePass {
         if (update.resized) {
             res.instances = updateMeshInstanceTransforms(res.instanceBindings);
             refitTLAS(tlas, res.instances, res.blases);
-            const blas = new Float32Array(concatBLASBuffers(res.blases));
-            this._bvhData = new Float32Array(tlas.buffer.byteLength / 4 + blas.length);
-            this._bvhData.set(new Float32Array(tlas.buffer));
-            this._bvhData.set(blas, tlas.buffer.byteLength / 4);
-            setDataTexture(this._bvhBufferTex, this._bvhData, 4);
-            this._tracePasses.forEach(pass => pass.setUniform('bvhColumns', textureDimensionsFromArray(this._bvhData.length / 4).columnsLog));
+            this._uploadBVH(new Float32Array(concatBLASBuffers(res.blases)));
         }
         else {
             const ranges = [];
@@ -603,8 +590,7 @@ class WebGLRayTracePass {
         if (res && tlas) {
             const dirty = updateMeshInstanceColors(res.instanceBindings, res.instances, this._dirtyColorMeshes);
             const ranges = updateTLASInstanceColors(tlas, res.instances, dirty);
-            for (const { offset, size } of ranges)
-                this._instancesBufferTex.updateDataRange(this._renderer.gl, this._instancesData, offset, size);
+            this._uploadInstanceRanges(ranges);
         }
         this._dirtyColorMeshes.clear();
     }
@@ -624,8 +610,7 @@ class WebGLRayTracePass {
         this._bvhData.set(new Float32Array(tlas.buffer));
         for (const { offset, size } of ranges.tlasRanges)
             this._bvhBufferTex.updateDataRange(this._renderer.gl, this._bvhData, offset, size);
-        for (const { offset, size } of ranges.instanceRanges)
-            this._instancesBufferTex.updateDataRange(this._renderer.gl, this._instancesData, offset, size);
+        this._uploadInstanceRanges(ranges.instanceRanges);
         this._dirtyTransformMeshes.clear();
         this._needsRefitTLAS = false;
         this._debugBvhData = undefined;
@@ -679,6 +664,7 @@ class WebGLRayTracePass {
             ? (1 - POWER_WEIGHTED_LIGHT_MIX) * fallbackPmf +
                 POWER_WEIGHTED_LIGHT_MIX * (weight / totalWeight)
             : fallbackPmf);
+        this._directLightLegacy = { env: this._envLightSelectionPmf, pmfs: this._analyticLightSelectionPmfs };
         let cumulativePmf = this._envLightSelectionPmf;
         this._analyticLightSelectionCdfs = Float32Array.from(this._analyticLightSelectionPmfs, (pmf) => {
             cumulativePmf += pmf;
@@ -714,9 +700,11 @@ class WebGLRayTracePass {
         const viewProjectionInv = this._viewProjInv;
         this._apertureRadius = cameraApertureRadius(camera);
         this._focusDistance = camera.focusDistance;
-        this._getViewProjInv(camera, viewProjectionInv);
+        mat4.invert(this._projectionInv, camera.getProjectionMatrix(this._depthAspect));
+        mat4.mul(viewProjectionInv, camera.transform, this._projectionInv);
         this._tracePasses.forEach((pass) => {
             pass.setUniform('viewProjectionInv', viewProjectionInv);
+            pass.setUniform('projectionInv', this._projectionInv);
             pass.setUniform('viewInv', camera.transform);
             // Zero for orthographic cameras, which have no depth of field.
             pass.setUniform('cameraApertureRadius', this._apertureRadius);
@@ -751,15 +739,27 @@ class WebGLRayTracePass {
         this._shadowCatcherPass.useTarget(target);
     }
     setQuality(options) {
+        const wasIndependent = this._independentSpectralPaths;
+        const research = researchTransport()?.configure(this, 'webgl');
+        this._independentSpectralPaths = !!research?.enabled;
+        const share = options.dispersionWavelengths !== 1;
+        if (this._spectral && (share !== this._shareSpectralPrefix || wasIndependent) && !research?.enabled) {
+            const shader = createRayTraceFragmentShader({
+                channelIndependentLight: true, shareSpectralPrefix: share
+            });
+            shader.parallelCompile = true;
+            this._mainPass.setShader(shader);
+        }
+        this._shareSpectralPrefix = share;
         this._tracePasses.forEach(pass => {
-            pass.setUniform('bounceLimit', normalizeBounces(options.bounces));
+            pass.setUniform('bounceLimit', normalizeBounces(options.bounces, MAX_PATH_EVENTS_WEBGL));
             pass.setUniform('bevelEnabled', options.bevel);
             pass.setUniform('dispersionWavelengths', options.dispersionWavelengths);
         });
     }
-    setWavelength(wavelength) {
+    setSpectralChannel(channel) {
         this._tracePasses.forEach((pass) => {
-            pass.setUniform('wavelength', wavelength);
+            pass.setUniform('spectralChannel', channel);
         });
     }
     setSampleCount(sampleCount) {
@@ -776,6 +776,10 @@ class WebGLRayTracePass {
     hasDispersion() {
         return this._spectral;
     }
+    hasSharedSpectralPrefix() {
+        // Research connections can disperse before the camera reaches a boundary.
+        return this._shareSpectralPrefix && !this._independentSpectralPaths;
+    }
     prepare() {
         if (this._needsUpdateMeshData) {
             this._updateMeshData();
@@ -791,6 +795,29 @@ class WebGLRayTracePass {
             this._updateMeshColors();
         if (this._pendingMaterialUpdate)
             this._updateMaterialData();
+        researchTransport()?.prepare(this, 'webgl');
+        const res = this._preparedMeshData;
+        if (res) {
+            const triangles = this._emissiveCache.collect(res.emissiveBindings, res.materials);
+            this._mainPass.setDefines({ HAS_EMISSIVE_LIGHTS: triangles.length > 0 });
+            if (!triangles.length && this._emissiveActive && this._directLightLegacy) {
+                this._envLightSelectionPmf = this._directLightLegacy.env;
+                this._analyticLightSelectionPmfs = Float32Array.from(this._directLightLegacy.pmfs);
+                this._tracePasses.forEach(pass => pass.setUniform('envLightSelectionPmf', this._envLightSelectionPmf));
+                this._needsUpdateAnalyticLightsBuffer = true;
+            }
+            this._emissiveActive = triangles.length > 0;
+            if (triangles.length) {
+                const lighting = prepareWebGLLightSampling(this._analyticLights, triangles, estimateEnvironmentPower(this._envImageSource));
+                this._envLightSelectionPmf = lighting.environmentPmf;
+                this._analyticLightSelectionPmfs = Float32Array.from(lighting.analyticPmfs);
+                const columns = setDataTexture(this._emissiveTex, lighting.data, 4).columnsLog;
+                this._mainPass.setUniforms({ emissiveLightData: this._emissiveTex, emissiveLightColumns: columns,
+                    emissiveChoiceOffset: lighting.emissiveTexels, emissiveChoiceCount: lighting.choiceCount,
+                    emissivePmfOffset: lighting.pmfOffset, emissiveWeightTotal: lighting.totalWeight, envLightSelectionPmf: lighting.environmentPmf });
+                this._needsUpdateAnalyticLightsBuffer = true;
+            }
+        }
         if (this._needsUpdateAnalyticLightsBuffer) {
             const analyticLights = this._analyticLights;
             analyticLights.length > 0 &&
@@ -843,14 +870,17 @@ class WebGLRayTracePass {
     // WebGL has uniform per-pixel counts; setSampleCount already includes offset.
     setSampleSequenceOffset(_offset) { }
     prepareAovs(state, camera, width, height, kinds) {
-        if (!kinds.length || !this._preparedMeshData || !this._tlas)
+        if (!kinds.length)
+            return true;
+        // An AOV channel may be the first thing to render a new scene.
+        this.prepare();
+        if (!this._preparedMeshData || !this._tlas)
             return true;
         const gl = this._renderer.gl;
         if (!gl.getExtension('EXT_color_buffer_float'))
             throw new Error('AOV requires EXT_color_buffer_float');
-        this.prepare();
         state.resize(width, height);
-        this._aovPass.setDefines({ AOV_REFLECTANCE: (aovMask(kinds) & 24) !== 0 });
+        this._aovPass.setDefines({ AOV_REFLECTANCE: (aovMask(kinds) & AOV_REFLECTANCE_MASK) !== 0 });
         if (!state.frame) {
             const packed = packAovScene(this._preparedMeshData, this._tlas, camera, width, height, state.history, this._aovPrimitiveCache.get(this._preparedMeshData, this._tlas));
             state.frame = packed.frame;
@@ -868,17 +898,17 @@ class WebGLRayTracePass {
         return center && accumulation;
     }
     renderAovs(state, camera, width, height, samples, cap, kinds, sequenceOffset = 0) {
-        if (!kinds.length || !this._preparedMeshData || !this._tlas)
-            return true;
         if (!this.prepareAovs(state, camera, width, height, kinds))
             return false;
+        if (!kinds.length || !this._preparedMeshData || !this._tlas)
+            return true;
         if (!state.centerReady) {
             this._aovCenter.createPass({}, state.center);
             state.centerReady = true;
             state.history.accept(state.frame);
         }
         const target = Math.min(samples, cap);
-        if ((aovMask(kinds) & 31) === 0)
+        if ((aovMask(kinds) & AOV_ACCUMULATED_MASK) === 0)
             state.samples = target;
         while (state.samples < target) {
             const output = state.accumulation[state.samples % 2], previous = state.accumulation[(state.samples + 1) % 2];
@@ -890,17 +920,33 @@ class WebGLRayTracePass {
         }
         return true;
     }
-    async readDepthSamples(area, aspect) {
+    async pickSurface(x, y, aspect) {
+        const source = this._preparedMeshData, tlas = this._tlas;
+        if (!source || !tlas)
+            return;
+        const values = await this._readDepthSamples({ x, y, size: 0 }, aspect, true);
+        if (!values || source !== this._preparedMeshData || tlas !== this._tlas)
+            return;
+        return resolveSurfaceHit(source, tlas, values);
+    }
+    readDepthSamples(area, aspect) {
+        return this._readDepthSamples(area, aspect);
+    }
+    async _readDepthSamples(area, aspect, picking = false) {
         if (this._depthAbort.signal.aborted || this._invalid || !this._preparedMeshData ||
             !this._renderer.isAllProgramCompiled())
             return;
         this.prepare();
-        this._depthPass.setUniform('depthArea', packDepthSampleArea(area, aspect ?? this._depthAspect));
+        const packed = packDepthSampleArea(area, aspect ?? this._depthAspect);
+        if (picking)
+            packed.set([-1, -1], 2);
+        this._depthPass.setUniform('depthArea', packed);
         this._depthPass.createPass({});
         const rgba = await readFloatPixelsAsync(this._renderer.gl, DEPTH_SAMPLE_GRID, DEPTH_SAMPLE_GRID, this._depthAbort.signal);
-        return unpackDepthSamples(rgba);
+        return picking ? rgba.slice(0, 4) : unpackDepthSamples(rgba);
     }
     dispose() {
+        researchTransport()?.dispose(this, 'webgl');
         this._skySource.dispose();
         this._depthAbort.abort();
         this._materialData?.dispose(this._renderer.gl);
@@ -909,19 +955,14 @@ class WebGLRayTracePass {
         const gl = this._renderer.gl;
         [
             this._lightTex,
+            this._emissiveTex,
             this._openPbrEnergyLut,
             this._envMap,
             this._envMapDistribution,
             this._backgroundTex,
             this._positionBufferTex,
-            this._normalBufferTex,
-            this._colorBufferTex,
-            this._tangentBufferTex,
-            this._uvBufferTex,
-            this._uv1BufferTex,
-            this._bvhBufferTex,
-            this._instancesBufferTex,
-            this._matIndexBufferTex
+            this._vertexAttributeTex,
+            this._bvhBufferTex
         ].forEach((texture) => texture.dispose(gl));
     }
 }