rayzee 10.0.0 → 11.1.0

package/src/TSL/MaterialProperties.js

@@ -6,6 +6,7 @@ import { BRDFWeights, MaterialCache, MaterialClassification, DFGResult, BaseFres
 import { PI, PI_INV, TWO_PI, EPSILON, MIN_ROUGHNESS, MIN_CLEARCOAT_ROUGHNESS, MAX_ROUGHNESS, XYZ_TO_REC709, square, classifyMaterial } from './Common.js';
 
 import { fresnelSchlickFloat, fresnel0ToIor, iorToFresnel0Vec3, iorToFresnel0, dielectricF0 } from './Fresnel.js';
+import { materialLayers } from './SceneResources.js';
 
 // -----------------------------------------------------------------------------
 // Microfacet Distribution Functions
@@ -407,8 +408,9 @@ export const evalIridescence = Fn( ( [ outsideIOR, eta2, cosTheta1, thinFilmThic
 // BRDF Weight Calculation
 // -----------------------------------------------------------------------------
 
-export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
+export const calculateBRDFWeights = Fn( ( [ material, mc, cache ], builder ) => {
 
+	const layers = materialLayers( builder );
 	// Use precomputed values from cache
 	const invRoughness = cache.invRoughness;
 	const metalFactor = cache.metalFactor;
@@ -438,10 +440,10 @@ export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
 	const diffuse = float( 1.0 ).sub( baseSpecularWeight )
 		.mul( float( 1.0 ).sub( material.metalness ) )
 		.mul( float( 1.0 ).sub( material.transmission ) ).toVar();
-	const sheen = material.sheen.mul( cache.maxSheenColor ).toVar();
+	const sheen = ( layers.sheen ? material.sheen.mul( cache.maxSheenColor ) : float( 0.0 ) ).toVar();
 
 	const clearcoat = float( 0.0 ).toVar();
-	If( mc.hasClearcoat, () => {
+	if ( layers.clearcoat ) If( mc.hasClearcoat, () => {
 
 		clearcoat.assign( material.clearcoat.mul( invRoughness ).mul( 0.4 ) );
 
@@ -471,17 +473,22 @@ export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
 	// Iridescence: shifts energy from diffuse to specular since it modifies specular F0
 	// This preserves the total weight (no inflation) while increasing specular importance
 	const iridescenceBase = invRoughness.mul( mc.isSmooth.select( float( 0.6 ), float( 0.5 ) ) );
-	const iridescenceWeight = material.iridescence.mul( iridescenceBase )
+	// Off, the weight is 0 but the shift is kept: min( 0, diffuse ) still moves a negative diffuse weight to specular.
+	const iridescenceWeight = layers.iridescence ? material.iridescence.mul( iridescenceBase )
 		.mul( float( 0.5 ).add( float( 0.5 ).mul(
 			material.iridescenceThicknessRange.y.sub( material.iridescenceThicknessRange.x ).div( 1000.0 )
 		) ) )
-		.mul( float( 0.5 ).add( float( 0.5 ).mul( material.iridescenceIOR.div( 2.0 ) ) ) );
+		.mul( float( 0.5 ).add( float( 0.5 ).mul( material.iridescenceIOR.div( 2.0 ) ) ) ) : float( 0.0 );
 	const iridescenceShift = min( iridescenceWeight, diffuse );
 	specular.addAssign( iridescenceShift );
 	diffuse.subAssign( iridescenceShift );
 
+	// The diffuse lobe's transmitted share is drawn on the other side, in proportion.
+	const diffuseTransmission = ( layers.diffuseTransmission ? diffuse.mul( material.diffuseTransmission ) : float( 0.0 ) ).toVar();
+	diffuse.subAssign( diffuseTransmission );
+
 	// Single normalization pass
-	const total = specular.add( diffuse ).add( sheen ).add( clearcoat ).add( transmission );
+	const total = specular.add( diffuse ).add( sheen ).add( clearcoat ).add( transmission ).add( diffuseTransmission );
 	const invTotal = float( 1.0 ).div( max( total, 0.001 ) );
 
 	return BRDFWeights( {
@@ -491,6 +498,7 @@ export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
 		clearcoat: clearcoat.mul( invTotal ),
 		transmission: transmission.mul( invTotal ),
 		iridescence: float( 0.0 ),
+		diffuseTransmission: diffuseTransmission.mul( invTotal ),
 	} );
 
 } );
@@ -508,8 +516,9 @@ export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
 //
 // Transmission is absent because it only produces NoL < 0. `weights` is normalised over all
 // lobes including transmission, so omitting its term is exact, not an approximation.
-export const calculateBSDFSamplingPDF = Fn( ( [ material, weights, dots ] ) => {
+export const calculateBSDFSamplingPDF = Fn( ( [ material, weights, dots ], builder ) => {
 
+	const layers = materialLayers( builder );
 	const pdf = float( 0.0 ).toVar();
 
 	If( dots.NoL.greaterThan( 0.0 ), () => {
@@ -517,21 +526,24 @@ export const calculateBSDFSamplingPDF = Fn( ( [ material, weights, dots ] ) => {
 		pdf.addAssign( weights.diffuse.mul( dots.NoL ).mul( PI_INV ) );
 
 		const specPdf = float( 0.0 ).toVar();
-		If( material.anisotropy.greaterThan( 0.0 ), () => {
+		// Raw roughness, not clamped: sampleGGXVNDF is called with material.roughness, and a
+		// clamp here would report a density the sampler never drew from.
+		const isotropic = () => {
 
-			const a = computeAnisoAlphas( material.roughness, material.anisotropy );
-			specPdf.assign( calculateVNDFPDFAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH, dots.NoV, dots.ToV, dots.BoV ) );
+			specPdf.assign( calculateVNDFPDF( dots.NoH, dots.NoV, material.roughness ) );
 
-		} ).Else( () => {
+		};
 
-			// Raw roughness, not clamped: sampleGGXVNDF is called with material.roughness, and a
-			// clamp here would report a density the sampler never drew from.
-			specPdf.assign( calculateVNDFPDF( dots.NoH, dots.NoV, material.roughness ) );
+		if ( ! layers.anisotropy ) isotropic();
+		else If( material.anisotropy.greaterThan( 0.0 ), () => {
 
-		} );
+			const a = computeAnisoAlphas( material.roughness, material.anisotropy );
+			specPdf.assign( calculateVNDFPDFAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH, dots.NoV, dots.ToV, dots.BoV ) );
+
+		} ).Else( isotropic );
 		pdf.addAssign( weights.specular.mul( specPdf ) );
 
-		If( weights.sheen.greaterThan( 0.0 ), () => {
+		if ( layers.sheen ) If( weights.sheen.greaterThan( 0.0 ), () => {
 
 			const sheenPdf = SheenDistribution( dots.NoH, material.sheenRoughness )
 				.mul( dots.NoH ).div( max( float( 4.0 ).mul( dots.VoH ), EPSILON ) );
@@ -539,7 +551,7 @@ export const calculateBSDFSamplingPDF = Fn( ( [ material, weights, dots ] ) => {
 
 		} );
 
-		If( weights.clearcoat.greaterThan( 0.0 ), () => {
+		if ( layers.clearcoat ) If( weights.clearcoat.greaterThan( 0.0 ), () => {
 
 			const ccRoughness = clamp( material.clearcoatRoughness, MIN_CLEARCOAT_ROUGHNESS, MAX_ROUGHNESS );
 			pdf.addAssign( weights.clearcoat.mul( calculateVNDFPDF( dots.NoH, dots.NoV, ccRoughness ) ) );
@@ -552,6 +564,21 @@ export const calculateBSDFSamplingPDF = Fn( ( [ material, weights, dots ] ) => {
 
 } );
 
+// The sampling density below the surface (cosBelow = −N·L > 0): only the diffuse transmission lobe draws there,
+// chosen with probability `weight` (BRDFWeights.diffuseTransmission).
+export const diffuseTransmissionPdf = Fn( ( [ weight, cosBelow ] ) => {
+
+	return weight.mul( cosBelow ).mul( PI_INV );
+
+} );
+
+// The diffuse transmission lobe's selection probability, for samplers outside the classify-once path.
+export const diffuseTransmissionWeight = Fn( ( [ material ] ) => {
+
+	return BRDFWeights.wrap( calculateBRDFWeightsFromMaterial( material ) ).diffuseTransmission;
+
+} );
+
 // Selection probabilities from `material` alone, for samplers outside the wavefront's
 // classify-once path. Must be the same weights whose density calculateBSDFSamplingPDF reports.
 export const calculateBRDFWeightsFromMaterial = Fn( ( [ material ] ) => {

package/src/TSL/MaterialTransmission.js

@@ -10,6 +10,7 @@ import { DistributionGGX } from './MaterialProperties.js';
 import { ImportanceSampleGGX } from './MaterialSampling.js';
 import { getRandomSample1D, getRandomSample2D, pcgHash } from './Random.js';
 import { handleSubsurfaceEntry, SubsurfaceEntryResult } from './Subsurface.js';
+import { materialLayers } from './SceneResources.js';
 
 // ================================================================================
 // STRUCTS (local to transmission)
@@ -158,8 +159,9 @@ export const calculateBeerLawAbsorption = /*@__PURE__*/ wgslFn( `
 export const sampleMicrofacetTransmission = Fn( ( [
 	V, N, ior, roughness, entering, dispersion, xi, rngState, pathWavelength,
 	pixelCoord, resolution, frame, dimBase,
-] ) => {
+], builder ) => {
 
+	const layers = materialLayers( builder );
 	const result = MicrofacetTransmissionResult( {
 		direction: vec3( 0.0 ),
 		halfVector: vec3( 0.0 ),
@@ -169,48 +171,7 @@ export const sampleMicrofacetTransmission = Fn( ( [
 		pathWavelength: pathWavelength,
 	} ).toVar();
 
-	// For smooth surfaces with dispersion, use perfect refraction with spectral IOR
-	If( roughness.lessThanEqual( 0.05 ).and( dispersion.greaterThan( 0.0 ) ), () => {
-
-		result.halfVector.assign( N );
-		result.didReflect.assign( false );
-
-		const eta = ior;
-		const etaRatio = select( entering, float( 1.0 ).div( eta ), eta ).toVar();
-
-		// Reuse the path's locked wavelength if any; else sample a new one and tint once.
-		If( pathWavelength.greaterThan( 0.0 ), () => {
-
-			const lockedIOR = iorFromWavelength( ior, dispersion, pathWavelength );
-			etaRatio.assign( select( entering, float( 1.0 ).div( lockedIOR ), lockedIOR ) );
-
-		} ).Else( () => {
-
-			const spectralSample = SpectralSample.wrap( sampleWavelengthForDispersion( ior, dispersion, getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 5 ) ), rngState, resolution, frame ) ) );
-			etaRatio.assign( select( entering, float( 1.0 ).div( spectralSample.ior ), spectralSample.ior ) );
-			result.colorWeight.assign( spectralSample.colorWeight );
-			result.pathWavelength.assign( spectralSample.wavelength );
-
-		} );
-
-		// Perfect refraction using surface normal
-		const refractDir = refract( V.negate(), N, etaRatio ).toVar();
-
-		// Check for total internal reflection
-		If( dot( refractDir, refractDir ).lessThan( 0.001 ), () => {
-
-			result.direction.assign( reflect( V.negate(), N ) );
-			result.didReflect.assign( true );
-			result.pdf.assign( 1.0 );
-
-		} ).Else( () => {
-
-			result.direction.assign( refractDir );
-			result.pdf.assign( 1.0 );
-
-		} );
-
-	} ).Else( () => {
+	const microfacet = () => {
 
 		// Use minimum roughness to avoid numerical issues for rough surfaces
 		const transmissionRoughness = max( MIN_ROUGHNESS, roughness );
@@ -223,7 +184,7 @@ export const sampleMicrofacetTransmission = Fn( ( [
 		const etaRatio = select( entering, float( 1.0 ).div( ior ), ior ).toVar();
 
 		// Reuse the path's locked wavelength if any; else sample a new one and tint once.
-		If( dispersion.greaterThan( 0.0 ), () => {
+		if ( layers.dispersion ) If( dispersion.greaterThan( 0.0 ), () => {
 
 			If( pathWavelength.greaterThan( 0.0 ), () => {
 
@@ -278,7 +239,51 @@ export const sampleMicrofacetTransmission = Fn( ( [
 
 		} );
 
-	} );
+	};
+
+	// For smooth surfaces with dispersion, use perfect refraction with spectral IOR
+	if ( ! layers.dispersion ) microfacet();
+	else If( roughness.lessThanEqual( 0.05 ).and( dispersion.greaterThan( 0.0 ) ), () => {
+
+		result.halfVector.assign( N );
+		result.didReflect.assign( false );
+
+		const eta = ior;
+		const etaRatio = select( entering, float( 1.0 ).div( eta ), eta ).toVar();
+
+		// Reuse the path's locked wavelength if any; else sample a new one and tint once.
+		If( pathWavelength.greaterThan( 0.0 ), () => {
+
+			const lockedIOR = iorFromWavelength( ior, dispersion, pathWavelength );
+			etaRatio.assign( select( entering, float( 1.0 ).div( lockedIOR ), lockedIOR ) );
+
+		} ).Else( () => {
+
+			const spectralSample = SpectralSample.wrap( sampleWavelengthForDispersion( ior, dispersion, getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 5 ) ), rngState, resolution, frame ) ) );
+			etaRatio.assign( select( entering, float( 1.0 ).div( spectralSample.ior ), spectralSample.ior ) );
+			result.colorWeight.assign( spectralSample.colorWeight );
+			result.pathWavelength.assign( spectralSample.wavelength );
+
+		} );
+
+		// Perfect refraction using surface normal
+		const refractDir = refract( V.negate(), N, etaRatio ).toVar();
+
+		// Check for total internal reflection
+		If( dot( refractDir, refractDir ).lessThan( 0.001 ), () => {
+
+			result.direction.assign( reflect( V.negate(), N ) );
+			result.didReflect.assign( true );
+			result.pdf.assign( 1.0 );
+
+		} ).Else( () => {
+
+			result.direction.assign( refractDir );
+			result.pdf.assign( 1.0 );
+
+		} );
+
+	} ).Else( microfacet );
 
 	return result;
 
@@ -430,7 +435,7 @@ export const handleMaterialTransparency = Fn( ( [
 	transmissiveTraversals,
 	currentMediumIOR, previousMediumIOR,
 	pathWavelength,
-] ) => {
+], builder ) => {
 
 	const result = MaterialInteractionResult( {
 		continueRay: false,
@@ -534,7 +539,7 @@ export const handleMaterialTransparency = Fn( ( [
 
 		// Subsurface (independent of transmission; works at transmission==0). Entry is a lottery
 		// (prob = weight) so 1-weight falls through to the opaque BRDF; exit is deterministic.
-		If( handled.not().and( material.subsurface.greaterThan( 0.0 ) ), () => {
+		if ( materialLayers( builder ).subsurface ) If( handled.not().and( material.subsurface.greaterThan( 0.0 ) ), () => {
 
 			const entering = dot( ray.direction, normal ).lessThan( 0.0 );
 			const doEnter = entering.not().or( getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 8 ) ), rngState, resolution, frame ).lessThan( material.subsurface ) );

package/src/TSL/MergeKernel.js

@@ -0,0 +1,224 @@
+/**
+ * MergeKernel.js — vertex merging (Georgiev et al. 2012, "Light Transport Simulation with Vertex Connection and
+ * Merging"): each camera vertex Shade left pending gathers the light vertices within the merge radius, as photon
+ * mapping does, MIS-weighted against every other strategy. It is the one strategy for light no path can connect:
+ * a lamp behind glass seen in a mirror, a caustic seen through water.
+ *
+ * The radius is a few pixels' footprint where the camera vertex is (Bidirectional.js mergeRadiusAt), so it grows
+ * with the distance from the camera. The light vertex cache is filed by that radius in shells, each a hash grid of
+ * cells two of its largest radii wide: one list a cell, threaded through the cached records' spare lane (`next`),
+ * built after the light pass by mergeInsert. A gather searches the one or two shells its sphere reaches, 2³ cells each.
+ */
+
+import {
+	Fn, float, vec3, vec4, int, uint, ivec3, If, Loop, instanceIndex, atomicLoad, atomicStore, atomicFunc, Return, dot, floor, max, min, select,
+	length, log2, exp2, Break, abs,
+} from 'three/tsl';
+
+import { evaluateMaterialResponse } from './MaterialEvaluation.js';
+import { calculateMaterialPDF } from './LightsSampling.js';
+import { luminance } from './Common.js';
+import { regularizePathContribution } from './PathTracerCore.js';
+import { resolveSurfaceMaterial, misMergePartial, misWeight, strategyWeight, mergeRadiusAt, mergeEta, facingSide, STRATEGY } from './Bidirectional.js';
+import { COUNTER } from '../Processor/QueueManager.js';
+import {
+	readRayRadiance, writeRayRadiance, pendingVertex, cachedVertex, readVertexTag, readVertexRecord, readVertexPosition,
+	readVertexNext, writeVertexNext, readLightPathLength,
+} from '../Processor/PackedRayBuffer.js';
+
+const WG_SIZE = 256;
+export const MERGE_EMPTY = 0xFFFFFFFF;
+// A cell's list is walked at most this far: a bound on the work, never reached at the radius the radius scale gives.
+const MAX_CELL_STEPS = 1024;
+
+// Shells of radius ratio 1.25: a sphere whose radius changes by (1 ± slope) across it spans at most two.
+export const MERGE_SHELL_RATIO = 1.25;
+const LOG2_RATIO = Math.log2( MERGE_SHELL_RATIO );
+
+const shellOf = ( bdpt, radius ) => int( max( floor( log2( radius.div( bdpt.mergeMin ) ).div( LOG2_RATIO ) ), 0.0 ) );
+
+// Twice the largest radius whose sphere can reach the shell (its own largest, over 1 − slope).
+const shellCell = ( bdpt, shell ) => bdpt.mergeMin.mul( exp2( float( shell.add( int( 1 ) ) ).mul( LOG2_RATIO ) ) ).mul( 2.0 )
+	.div( max( float( 1.0 ).sub( bdpt.mergeSlope ), 0.5 ) );
+
+const cellHash = ( shell, cell, hashMask ) => uint( cell.x ).mul( uint( 73856093 ) )
+	.bitXor( uint( cell.y ).mul( uint( 19349663 ) ) )
+	.bitXor( uint( cell.z ).mul( uint( 83492791 ) ) )
+	.bitXor( uint( shell ).mul( uint( 2654435761 ) ) )
+	.bitAnd( hashMask );
+
+// A light vertex's shell and cell.
+const filing = ( bdpt, p ) => {
+
+	const shell = shellOf( bdpt, mergeRadiusAt( bdpt, p ) ).toVar();
+	return { shell, cell: ivec3( floor( p.div( shellCell( bdpt, shell ) ) ) ).toVar() };
+
+};
+
+/** Empties every list head. */
+export function buildMergeClearKernel( { head, hashSize } ) {
+
+	return Fn( () => {
+
+		If( instanceIndex.lessThan( uint( hashSize ) ), () => {
+
+			atomicStore( head.element( instanceIndex ), uint( MERGE_EMPTY ) );
+
+		} );
+
+	} )().compute( Math.ceil( hashSize / WG_SIZE ) * WG_SIZE, [ WG_SIZE ] );
+
+}
+
+/** Files each light vertex of this frame at the head of its cell's list. */
+export function buildMergeInsertKernel( { hitBufferRW, head, bidirectional: bdpt } ) {
+
+	const { lightPaths, slotsPerPath, lightTag, hashMask } = bdpt;
+
+	return Fn( () => {
+
+		const slot = instanceIndex.toVar();
+		If( slot.greaterThanEqual( lightPaths.mul( slotsPerPath ) ), () => {
+
+			Return();
+
+		} );
+
+		const depth = slot.mod( slotsPerPath ).toVar();
+		If( depth.greaterThanEqual( readLightPathLength( hitBufferRW, cachedVertex( slot.sub( depth ) ), lightTag ) ), () => {
+
+			Return();
+
+		} );
+
+		const at = cachedVertex( slot );
+		const { shell, cell } = filing( bdpt, readVertexPosition( hitBufferRW, at ) );
+		const bucket = cellHash( shell, cell, hashMask );
+		writeVertexNext( hitBufferRW, at, atomicFunc( 'atomicExchange', head.element( bucket ), slot ) );
+
+	} );
+
+}
+
+export function buildMergeKernel( params ) {
+
+	const {
+		rayBufferRW, hitBufferRO, activeIndicesRO, counters, head, materialBuffer, bidirectional: bdpt,
+		maxBounceCount, globalIlluminationIntensity, fireflyThreshold, accumFrame,
+		// Some material passes light through diffusely: light arriving from behind its surface merges too.
+		diffuseTransmission = true,
+	} = params;
+	const { passTag, slotsPerPath, strategyView, hashMask } = bdpt;
+
+	return Fn( () => {
+
+		const tid = instanceIndex;
+		If( tid.greaterThanEqual( atomicLoad( counters.element( uint( COUNTER.ENTERING_COUNT ) ) ) ), () => {
+
+			Return();
+
+		} );
+
+		const rayID = activeIndicesRO.element( tid ).toVar();
+		const pending = pendingVertex( rayID );
+		If( readVertexTag( hitBufferRO, pending ).notEqual( passTag ), () => {
+
+			Return();
+
+		} );
+
+		const cam = readVertexRecord( hitBufferRO, pending );
+		const cameraDepth = int( cam.extra ).toVar();
+		// A merged path of k scattering vertices: the camera's cameraDepth + 1 and the light's l share one.
+		const lightBudget = int( maxBounceCount ).add( int( 1 ) ).sub( cameraDepth ).toVar();
+		const material = resolveSurfaceMaterial( cam.materialIndex, cam.uv, cam.N, materialBuffer );
+		const gathered = vec3( 0.0 ).toVar();
+
+		const radius = mergeRadiusAt( bdpt, cam.position ).toVar();
+		const radius2 = radius.mul( radius ).toVar();
+		const eta = mergeEta( bdpt, radius ).toVar();
+		const trusted = eta.mul( bdpt.mergeTrust );
+		const vc = float( 1.0 ).div( max( trusted.mul( trusted ), 1e-30 ) ).toVar();
+		// The shells the sphere reaches: its radius at its nearest and farthest points from the camera.
+		const distance = length( cam.position.sub( bdpt.cameraPosition ) ).toVar();
+		const nearShell = shellOf( bdpt, max( bdpt.mergeConst.add( bdpt.mergeSlope.mul( max( distance.sub( radius ), 0.0 ) ) ), bdpt.mergeMin ) ).toVar();
+		const farShell = min( shellOf( bdpt, bdpt.mergeConst.add( bdpt.mergeSlope.mul( distance.add( radius ) ) ) ), nearShell.add( int( 1 ) ) ).toVar();
+
+		// Per shell, the 2 × 2 × 2 cells the sphere can reach, the cells being at least two radii wide.
+		Loop( { start: int( 0 ), end: int( 16 ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			const shell = nearShell.add( i.shiftRight( int( 3 ) ) ).toVar();
+			If( shell.greaterThan( farShell ), () => {
+
+				Break();
+
+			} );
+			const cellSize = shellCell( bdpt, shell ).toVar();
+			const corner = i.bitAnd( int( 7 ) );
+			const cell = ivec3( floor( cam.position.div( cellSize ).sub( 0.5 ) ) )
+				.add( ivec3( corner.bitAnd( int( 1 ) ), corner.shiftRight( int( 1 ) ).bitAnd( int( 1 ) ), corner.shiftRight( int( 2 ) ) ) ).toVar();
+			const slot = atomicLoad( head.element( cellHash( shell, cell, hashMask ) ) ).toVar();
+			const steps = int( 0 ).toVar();
+
+			Loop( slot.notEqual( uint( MERGE_EMPTY ) ).and( steps.lessThan( int( MAX_CELL_STEPS ) ) ), () => {
+
+				const at = cachedVertex( slot );
+				const position = readVertexPosition( hitBufferRO, at ).toVar();
+				const offset = position.sub( cam.position );
+				const l = int( slot.mod( slotsPerPath ) ).add( int( 1 ) ).toVar();
+				If( dot( offset, offset ).lessThan( radius2 ).and( l.lessThanEqual( lightBudget ) ), () => {
+
+					// Its own shell and cell only: two lists sharing a bucket (a hash collision) must not count it twice.
+					const own = filing( bdpt, position );
+					If( own.shell.equal( shell ).and( own.cell.x.equal( cell.x ) ).and( own.cell.y.equal( cell.y ) ).and( own.cell.z.equal( cell.z ) ), () => {
+
+						const light = readVertexRecord( hitBufferRO, at );
+						const cosShading = dot( light.V, cam.N ).toVar();
+						const cosFacet = dot( light.V, cam.facetN ).toVar();
+						// Light arriving on this side, or from behind a surface that passes it through diffusely. A corner's
+						// other wall stays in: its light vertices stand in for the part of the sphere past the corner, which
+						// the density divides by too.
+						const onThisSide = cosShading.greaterThan( 0.0 ).and( cosFacet.greaterThan( 0.0 ) );
+						const throughSurface = material.diffuseTransmission.greaterThan( 0.0 ).and( cosShading.lessThan( 0.0 ) ).and( cosFacet.lessThan( 0.0 ) );
+						If( diffuseTransmission ? onThisSide.or( throughSurface ) : onThisSide, () => {
+
+							const f = evaluateMaterialResponse( cam.V, light.V, cam.N, material );
+							const wLight = misMergePartial( light, calculateMaterialPDF( cam.V, light.V, cam.N, material ), vc );
+							const reverseN = diffuseTransmission ? facingSide( cam.N, light.V, material ) : cam.N;
+							const wCamera = misMergePartial( cam, calculateMaterialPDF( light.V, cam.V, reverseN, material ), vc );
+							const scattering = cameraDepth.add( l );
+							// Alone, a path of k scattering vertices is reached by k merges.
+							const weight = strategyWeight( strategyView, STRATEGY.MERGE, misWeight( wLight, wCamera ), float( 1.0 ).div( float( scattering ) ) );
+							const gi = select( scattering.greaterThan( int( 1 ) ), globalIlluminationIntensity, float( 1.0 ) );
+							// The photon's flux is per unit area; the BSDF wants it per projected solid angle (Veach 5.3.2).
+							const correction = diffuseTransmission ? abs( cosShading ).div( max( abs( cosFacet ), 1e-4 ) ) : cosShading.div( max( cosFacet, 1e-4 ) );
+							gathered.addAssign( regularizePathContribution(
+								cam.throughput.mul( f ).mul( light.throughput ).mul( weight.mul( correction ).div( eta ).mul( gi ) ),
+								float( scattering.sub( int( 1 ) ) ), fireflyThreshold, int( accumFrame ),
+							) );
+
+						} );
+
+					} );
+
+				} );
+
+				slot.assign( readVertexNext( hitBufferRO, at ) );
+				steps.addAssign( int( 1 ) );
+
+			} );
+
+		} );
+
+		If( luminance( gathered ).greaterThan( 0.0 ), () => {
+
+			const radiance = readRayRadiance( rayBufferRW, rayID ).toVar();
+			writeRayRadiance( rayBufferRW, rayID, vec4( radiance.xyz.add( gathered ), radiance.w ) );
+
+		} );
+
+	} );
+
+}
+
+export { WG_SIZE as MERGE_WG_SIZE };