three-gpu-pathtracer 0.0.24 → 0.0.25

package/src/webgpu/compute/wavefront/MaterialKernel.js

@@ -0,0 +1,371 @@
+import { Vector2 } from 'three';
+import { StorageBufferAttribute, StorageTexture } from 'three/webgpu';
+import { ComputeKernel } from '../ComputeKernel.js';
+import { uniform, storage, textureStore, globalId } from 'three/tsl';
+import { proxy, proxyFn, rayStruct, wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { rngInit, rand1, rand2, RNG_INDEX_RAY_JITTER, RNG_INDEX_ALPHA_TEST, RNG_INDEX_RUSSIAN_ROULETTE, RNG_INDEX_DISPERSION_WAVELENGTH } from '../../nodes/random.wgsl.js';
+import { rayDataStruct, rayQueueAtomicStruct, pixelQueueStruct } from './structs.js';
+import { SAMPLE_ACTIVE_FLAG, SAMPLE_COUNT_MASK, SAMPLE_DISPATCHED_FLAG } from '../../constants.js';
+import { applyDispersionFunc, dispersionColorWeightFunc, DISPERSION_MIN_WAVELENGTH, DISPERSION_MAX_WAVELENGTH, transmissionAttenuationFunc } from '../../nodes/material.wgsl.js';
+import { isTerminatingScatterFunc, offsetRayOriginFunc } from '../../nodes/utils.wgsl.js';
+import { LIGHT_EPSILON } from '../../nodes/lights.wgsl.js';
+
+// Pure material evaluation and ray generation: terminated slots pull a recycled pixel and emit a
+// fresh camera ray; live slots evaluate the surface staged by LogicKernel, sample the bsdf, and
+// enqueue the next bounce ray plus the NEE shadow ray toward the light LogicKernel selected.
+export class MaterialKernel extends ComputeKernel {
+
+	constructor( ) {
+
+		const params = {
+			bvhData: { value: null },
+			material: { value: null },
+
+			seed: uniform( 0, 'uint' ),
+			targetDimensions: uniform( new Vector2() ),
+			maxSamples: uniform( 0, 'uint' ),
+			rayCount: uniform( 0, 'uint' ),
+			filterGlossy: uniform( 1 ),
+			maxTransparentBounces: uniform( 5, 'uint' ),
+			maxBounces: uniform( 5, 'uint' ),
+
+			sampleCountTarget: textureStore( new StorageTexture( 1, 1 ) ).toReadWrite(),
+
+			rayDataStorage: storage( new StorageBufferAttribute( 1, 1 ), rayDataStruct ),
+			rayQueue: storage( new StorageBufferAttribute( 1, 1 ), rayQueueAtomicStruct ),
+			shadowRayQueue: storage( new StorageBufferAttribute( 1, 1 ), rayQueueAtomicStruct ),
+			pixelQueue: storage( new StorageBufferAttribute( 1, 1 ), pixelQueueStruct ),
+
+			globalId: globalId,
+		};
+
+		const getCameraRayFn = proxyFn( 'bvhData.value.fns.getCameraRay', params );
+		const sampleTrianglePointFn = proxyFn( 'bvhData.value.fns.sampleTrianglePoint', params );
+		const getSurfaceRecordFn = proxyFn( 'bvhData.value.fns.getSurfaceRecord', params );
+		const bsdfSampleFn = proxyFn( 'material.value.bsdfSample', params );
+		const bsdfEvalPdfFn = proxyFn( 'material.value.bsdfEvalPdf', params );
+
+		const fn = wgslTagFn/* wgsl */`
+
+			fn compute(
+				seed: u32,
+				targetDimensions: vec2u,
+				maxSamples: u32,
+				rayCount: u32,
+				filterGlossy: f32,
+				maxTransparentBounces: u32,
+				maxBounces: u32,
+
+				globalId: vec3u
+			) -> void {
+
+				let rayDataStorage = &${ params.rayDataStorage };
+				let rayQueue = &${ params.rayQueue };
+				let shadowRayQueue = &${ params.shadowRayQueue };
+				let pixelQueue = &${ params.pixelQueue };
+
+				let materials = &${ proxy( 'bvhData.value.storage.materials', params ) };
+				let transforms = &${ proxy( 'bvhData.value.storage.transforms', params ) };
+
+				// bound by "rayCount" rather than the pool length. The dispatch rounds up to the
+				// workgroup size and those extra slots hold a zeroed pixel index
+				let index = globalId.x;
+				if ( index >= rayCount ) {
+
+					return;
+
+				}
+
+				let input = ( *rayDataStorage )[ index ];
+				if ( input.objectIndex < 0 ) {
+
+					// the slot's path has terminated: recycle the pixel through the overflow queue and
+					// generate a fresh camera ray
+					var pixelIndex = input.pixelIndex;
+					let elementCount = atomicLoad( &pixelQueue.elementCount );
+					if ( elementCount > 0u ) {
+
+						// TODO: If we've pulled off a pixel that's already finished we currently just
+						// write a no-op ray, wasting a frame. It may be better to iterate over a few
+						// points in the queue to see if we can find one we can use.
+						let queueIndex = atomicAdd( &pixelQueue.current, 1u ) % elementCount;
+						pixelIndex = atomicExchange( &pixelQueue.elements[ queueIndex ], pixelIndex );
+
+					}
+
+					let indexUV = vec2u( pixelIndex >> 16, pixelIndex & 0xFFFF );
+
+					// skip the pixel if it has hit the sample limit
+					let combinedField = textureLoad( ${ params.sampleCountTarget }, indexUV ).r;
+					let samples = ( ${ SAMPLE_COUNT_MASK }u & combinedField );
+					let isComplete = maxSamples != 0u && samples >= maxSamples;
+
+					if ( isComplete ) {
+
+						rayDataStorage[ index ].pixelIndex = pixelIndex;
+						rayDataStorage[ index ].rayIntersectionIndex = - 1;
+						rayDataStorage[ index ].shadowRayIntersectionIndex = - 1;
+						return;
+
+					}
+
+					${ rngInit }( indexUV, seed + samples, 0 );
+
+					let uv = vec2f( indexUV ) / vec2f( targetDimensions );
+					let jitteredUv = uv + ${ rand2 }( ${ RNG_INDEX_RAY_JITTER } ) / vec2f( targetDimensions );
+					var ray: ${ rayStruct };
+					if ( ! ${ getCameraRayFn }( jitteredUv, vec2f( targetDimensions ), &ray ) ) {
+
+						// the camera declined the pixel, so leave the slot dormant for this round
+						// TODO: same as above - this work is a bit wasteful and leaves slots empty for
+						// a frame. Is it possible to quickly skip rays outside the mask or are finished?
+						rayDataStorage[ index ].pixelIndex = pixelIndex;
+						rayDataStorage[ index ].rayIntersectionIndex = - 1;
+						rayDataStorage[ index ].shadowRayIntersectionIndex = - 1;
+						return;
+
+					}
+
+					ray.direction = normalize( ray.direction );
+
+					let rayIndex = atomicAdd( &rayQueue.length, 1u );
+					rayQueue.elements[ rayIndex ].origin = ray.origin;
+					rayQueue.elements[ rayIndex ].direction = ray.direction;
+					rayQueue.elements[ rayIndex ].pixelIndex = pixelIndex;
+					rayQueue.elements[ rayIndex ].currentBounce = 0u;
+					rayQueue.elements[ rayIndex ].seed = seed + samples;
+					rayQueue.elements[ rayIndex ].alphaDepth = 0u;
+					rayQueue.elements[ rayIndex ].maxDist = ray.maxDist;
+
+					rayDataStorage[ index ].origin = ray.origin;
+					rayDataStorage[ index ].direction = ray.direction;
+					rayDataStorage[ index ].pixelIndex = pixelIndex;
+					rayDataStorage[ index ].seed = seed + samples;
+					rayDataStorage[ index ].currentBounce = 0u;
+					rayDataStorage[ index ].throughputColor = vec3f( 1.0 );
+					rayDataStorage[ index ].resultColor = vec4f( 0.0, 0.0, 0.0, 1.0 );
+					rayDataStorage[ index ].scatterColor = vec3f( 1.0 );
+					rayDataStorage[ index ].scatterPdf = 1.0;
+					rayDataStorage[ index ].minPdf = 1.0;
+					rayDataStorage[ index ].isFullyTransmissive = 1u;
+					rayDataStorage[ index ].emission = vec3f( 0.0 );
+					rayDataStorage[ index ].lightPdf = 0.0;
+					rayDataStorage[ index ].alphaDepth = 0u;
+					rayDataStorage[ index ].maxDist = ray.maxDist;
+					rayDataStorage[ index ].rayIntersectionIndex = i32( rayIndex );
+					rayDataStorage[ index ].shadowRayIntersectionIndex = - 1;
+					rayDataStorage[ index ].dispersionWavelength = - mix( ${ DISPERSION_MIN_WAVELENGTH }.0, ${ DISPERSION_MAX_WAVELENGTH }.0, ${ rand1 }( ${ RNG_INDEX_DISPERSION_WAVELENGTH } ) );
+
+					// write the active params & dispatched flag
+					textureStore( ${ params.sampleCountTarget }, indexUV, vec4( ${ SAMPLE_ACTIVE_FLAG }u | ${ SAMPLE_DISPATCHED_FLAG }u | samples ) );
+
+				} else {
+
+					// evaluate the surface staged by LogicKernel
+					let indexUV = vec2u( input.pixelIndex >> 16, input.pixelIndex & 0xFFFF );
+					${ rngInit }( indexUV, input.seed, input.currentBounce + input.alphaDepth );
+
+					let objectInfo = transforms[ u32( input.objectIndex ) ];
+					var materialInfo = ( *materials )[ objectInfo.materialIndex ];
+
+					// a matte surface hit by the camera ray renders as a fully transparent
+					let isMatte = materialInfo.matte != 0 && input.currentBounce == 0u;
+					if ( isMatte ) {
+
+						rayDataStorage[ index ].resultColor = vec4f( 0.0 );
+						rayDataStorage[ index ].throughputColor = vec3f( 0.0 );
+						rayDataStorage[ index ].emission = vec3f( 0.0 );
+						rayDataStorage[ index ].lightPdf = 0.0;
+						rayDataStorage[ index ].shadowRayIntersectionIndex = - 1;
+						return;
+
+					}
+
+					// apply per-object colors
+					materialInfo.color *= objectInfo.color.rgb;
+					materialInfo.opacity *= objectInfo.color.a;
+
+					var vertexData = ${ sampleTrianglePointFn }( input.barycoord, input.indices );
+					vertexData.normal = normalize( transpose( objectInfo.inverseMatrixWorld ) * vertexData.normal );
+					vertexData.tangent = vec4f( ( objectInfo.matrixWorld * vec4f( vertexData.tangent.xyz, 0.0 ) ).xyz, vertexData.tangent.w );
+					vertexData.position = objectInfo.matrixWorld * vertexData.position;
+
+					let view = - input.direction;
+
+					// blur glossy surfaces after low-probability bounces to suppress fireflies,
+					// from the Cycles "filter glossy" approach in integrator/surface_shader.h
+					let blurRoughness = sqrt( clamp( 1.0 - filterGlossy * input.minPdf, 0.0, 1.0 ) ) * 0.5;
+
+					var surface = ${ getSurfaceRecordFn }( materialInfo, vertexData, input.side, input.normal, view, blurRoughness );
+
+					// Stochastically pass through partially transparent surfaces by re-enqueueing
+					// the ray at the hit point, advancing the alpha depth but not the bounce count.
+					let passesThrough = ${ rand1 }( ${ RNG_INDEX_ALPHA_TEST } ) > surface.opacity;
+					if ( passesThrough ) {
+
+						// out of transparent bounces, so stop rather than shading a surface that
+						// should be invisible. A zeroed throughput terminates in LogicKernel.
+						if ( input.alphaDepth >= maxTransparentBounces ) {
+
+							rayDataStorage[ index ].throughputColor = vec3f( 0.0 );
+							rayDataStorage[ index ].emission = vec3f( 0.0 );
+							rayDataStorage[ index ].lightPdf = 0.0;
+							rayDataStorage[ index ].shadowRayIntersectionIndex = - 1;
+							return;
+
+						}
+
+						let alphaIndex = atomicAdd( &rayQueue.length, 1u );
+						rayQueue.elements[ alphaIndex ].origin = ${ offsetRayOriginFunc }( vertexData.position.xyz, input.direction, input.normal );
+						rayQueue.elements[ alphaIndex ].direction = input.direction;
+						rayQueue.elements[ alphaIndex ].pixelIndex = input.pixelIndex;
+						rayQueue.elements[ alphaIndex ].currentBounce = input.currentBounce;
+						rayQueue.elements[ alphaIndex ].seed = input.seed;
+						rayQueue.elements[ alphaIndex ].alphaDepth = input.alphaDepth + 1u;
+						// the origin advanced to the hit point, so the remaining budget shrinks by the
+						// distance already traced
+						rayQueue.elements[ alphaIndex ].maxDist = max( input.maxDist - input.dist, 0.0 );
+
+						// the surface is skipped, so no scatter or emission is staged for LogicKernel.
+						// "pdf" is left alone so the previous scatter still weights the forward MIS,
+						// and "bsdf" matches it so applying the scatter leaves the throughput as is.
+						rayDataStorage[ index ].alphaDepth = input.alphaDepth + 1u;
+						rayDataStorage[ index ].emission = vec3f( 0.0 );
+						rayDataStorage[ index ].scatterColor = vec3f( input.scatterPdf );
+						rayDataStorage[ index ].lightPdf = 0.0;
+						rayDataStorage[ index ].origin = rayQueue.elements[ alphaIndex ].origin;
+						rayDataStorage[ index ].rayIntersectionIndex = i32( alphaIndex );
+						rayDataStorage[ index ].shadowRayIntersectionIndex = - 1;
+						return;
+
+					}
+
+					// apply the hero wavelength to dispersive surfaces, folding the spectral weight
+					// into the throughput at the path's first dispersive interaction
+					var throughputColor = input.throughputColor;
+					let isDispersive = materialInfo.dispersion > 0.0 && surface.ior > 1.0 && surface.transmission > 0.0 && ! surface.thinWall;
+					if ( isDispersive ) {
+
+						let wavelength = abs( input.dispersionWavelength );
+						${ applyDispersionFunc }( &surface, materialInfo.dispersion, wavelength );
+						if ( input.dispersionWavelength < 0.0 ) {
+
+							rayDataStorage[ index ].dispersionWavelength = wavelength;
+							throughputColor *= ${ dispersionColorWeightFunc }( wavelength );
+							rayDataStorage[ index ].throughputColor = throughputColor;
+
+						}
+
+					}
+
+					// attenuate the light transmitted through the volume when exiting a backface so
+					// the surface's emission and NEE resolve against the attenuated throughput
+					if ( input.side < 0.0 && materialInfo.transmission > 0.0 ) {
+
+						throughputColor *= ${ transmissionAttenuationFunc }( input.dist, materialInfo.attenuationColor, materialInfo.attenuationDistance );
+						rayDataStorage[ index ].throughputColor = throughputColor;
+
+					}
+
+					// sample the next bounce direction and stage the scatter state for LogicKernel
+					var scatterRec = ${ bsdfSampleFn }( view, surface );
+					let newBounce = input.currentBounce + 1u;
+
+					// decide termination now so finished paths skip the bounce trace entirely - a
+					// zeroed pdf reads as a terminating scatter in LogicKernel, which still resolves
+					// the surface's emission and NEE before freeing the slot
+					var isTerminated = newBounce >= maxBounces || all( scatterRec.color == vec3f( 0.0 ) ) || ${ isTerminatingScatterFunc }( scatterRec );
+
+					// russian roulette early out:
+					// Matches Cycles path_state_continuation_probability in integrator/path_state.h
+					if ( ! isTerminated && newBounce >= 3u ) {
+
+						let rrThroughput = throughputColor * scatterRec.color / scatterRec.pdf;
+						let rrProb = saturate( sqrt( max( max( rrThroughput.r, rrThroughput.g ), rrThroughput.b ) ) );
+						isTerminated = rrProb <= 0.0 || ${ rand1 }( ${ RNG_INDEX_RUSSIAN_ROULETTE } ) > rrProb;
+						if ( ! isTerminated ) {
+
+							// fold the survival boost into the scatter color so LogicKernel's
+							// throughput update applies it without a separate division
+							scatterRec.color /= rrProb;
+
+						}
+
+					}
+
+					// Write the ray storage content here since things like the emissive value is read
+					// in the logic kernel on the subsequent frame.
+					rayDataStorage[ index ].scatterColor = scatterRec.color;
+					rayDataStorage[ index ].scatterPdf = select( scatterRec.pdf, 0.0, isTerminated );
+					rayDataStorage[ index ].minPdf = min( input.minPdf, scatterRec.pdf );
+					rayDataStorage[ index ].isFullyTransmissive = input.isFullyTransmissive & select( 0u, 1u, scatterRec.isTransmissive );
+					rayDataStorage[ index ].emission = surface.emission;
+					rayDataStorage[ index ].currentBounce = newBounce;
+
+					// the NEE shadow ray below still resolves the surface's direct light, so only
+					// the bounce segment is skipped for finished paths
+					if ( ! isTerminated ) {
+
+						let rayIndex = atomicAdd( &rayQueue.length, 1u );
+						rayQueue.elements[ rayIndex ].origin = ${ offsetRayOriginFunc }( vertexData.position.xyz, scatterRec.direction, input.normal );
+						rayQueue.elements[ rayIndex ].direction = scatterRec.direction;
+						rayQueue.elements[ rayIndex ].pixelIndex = input.pixelIndex;
+						rayQueue.elements[ rayIndex ].currentBounce = newBounce;
+						rayQueue.elements[ rayIndex ].seed = input.seed;
+						rayQueue.elements[ rayIndex ].alphaDepth = input.alphaDepth;
+						rayQueue.elements[ rayIndex ].maxDist = 0.0;
+						rayDataStorage[ index ].rayIntersectionIndex = i32( rayIndex );
+
+						rayDataStorage[ index ].origin = rayQueue.elements[ rayIndex ].origin;
+						rayDataStorage[ index ].direction = scatterRec.direction;
+
+					}
+
+					// evaluate the bsdf toward the light LogicKernel selected and enqueue the shadow ray.
+					// the light pdf will be 0 if NEE is disabled.
+					var lightPdf = input.lightPdf;
+					if ( lightPdf > 0.0 ) {
+
+						let evalRec = ${ bsdfEvalPdfFn }( view, input.lightDirection, surface );
+						if ( evalRec.pdf > 0.0 ) {
+
+							rayDataStorage[ index ].lightBsdf = evalRec.color;
+							rayDataStorage[ index ].lightBsdfPdf = evalRec.pdf;
+
+							let shadowIndex = atomicAdd( &shadowRayQueue.length, 1u );
+							shadowRayQueue.elements[ shadowIndex ].origin = ${ offsetRayOriginFunc }( vertexData.position.xyz, input.lightDirection, input.normal );
+							shadowRayQueue.elements[ shadowIndex ].direction = input.lightDirection;
+							shadowRayQueue.elements[ shadowIndex ].pixelIndex = input.pixelIndex;
+							shadowRayQueue.elements[ shadowIndex ].currentBounce = input.currentBounce;
+							shadowRayQueue.elements[ shadowIndex ].seed = input.seed;
+							shadowRayQueue.elements[ shadowIndex ].alphaDepth = input.alphaDepth;
+							shadowRayQueue.elements[ shadowIndex ].maxDist = input.lightDist - ${ LIGHT_EPSILON };
+							rayDataStorage[ index ].shadowRayIntersectionIndex = i32( shadowIndex );
+
+						} else {
+
+							lightPdf = 0.0;
+
+						}
+
+					}
+
+					if ( lightPdf <= 0.0 ) {
+
+						rayDataStorage[ index ].lightPdf = 0.0;
+						rayDataStorage[ index ].shadowRayIntersectionIndex = - 1;
+
+					}
+
+				}
+
+			}
+		`;
+
+		super( fn( params ) );
+
+		this.defineUniformAccessors( params );
+
+	}
+
+}

package/src/webgpu/compute/wavefront/PopulatePixelIndicesKernel.js

@@ -0,0 +1,72 @@
+import { Vector2 } from 'three';
+import { StorageBufferAttribute } from 'three/webgpu';
+import { uniform, storage, globalId } from 'three/tsl';
+import { ComputeKernel } from '../ComputeKernel.js';
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { rayDataStruct, pixelQueueNonAtomicStruct } from './structs.js';
+
+// Runs once per reset: assigns each of the first rayData-pool-count pixels to a path slot and parks
+// the overflow pixel indices in the pixel queue. Slots are initialized so LogicKernel skips them and
+// MaterialKernel immediately generates fresh camera rays. Later budget changes are handled by
+// resizing the pool in the render loop, with ResetSlotsKernel returning retired slots' pixels.
+export class PopulatePixelIndicesKernel extends ComputeKernel {
+
+	constructor( ) {
+
+		const params = {
+			rayDataStorage: storage( new StorageBufferAttribute( 1, 1 ), rayDataStruct ),
+			pixelQueue: storage( new StorageBufferAttribute( 1, 1 ), pixelQueueNonAtomicStruct ),
+			targetDimensions: uniform( new Vector2() ),
+			frameBudget: uniform( 0, 'uint' ),
+			globalId: globalId,
+		};
+
+		const fn = wgslTagFn/* wgsl */`
+			fn compute( targetDimensions: vec2u, frameBudget: u32, globalId: vec3u ) -> void {
+
+				let rayDataStorage = &${ params.rayDataStorage };
+				let pixelQueue = &${ params.pixelQueue };
+
+				if ( globalId.x >= targetDimensions.x || globalId.y >= targetDimensions.y ) {
+
+					return;
+
+				}
+
+				let rayCount = min( frameBudget, arrayLength( rayDataStorage ) );
+				let pixelCount = targetDimensions.x * targetDimensions.y;
+				if ( globalId.x == 0u && globalId.y == 0u ) {
+
+					pixelQueue.current = 0u;
+					pixelQueue.elementCount = select( 0u, pixelCount - rayCount, pixelCount >= rayCount );
+
+				}
+
+				let pixelHash = ( globalId.x << 16 ) | globalId.y;
+				let pixelIndex = globalId.x + globalId.y * targetDimensions.x;
+				if ( pixelIndex < rayCount ) {
+
+					rayDataStorage[ pixelIndex ].pixelIndex = pixelHash;
+					rayDataStorage[ pixelIndex ].resultColor = vec4f( 0.0 );
+					rayDataStorage[ pixelIndex ].throughputColor = vec3f( 0.0 );
+					rayDataStorage[ pixelIndex ].objectIndex = - 1;
+					rayDataStorage[ pixelIndex ].alphaDepth = 0u;
+					rayDataStorage[ pixelIndex ].rayIntersectionIndex = - 1;
+					rayDataStorage[ pixelIndex ].shadowRayIntersectionIndex = - 1;
+
+				} else {
+
+					pixelQueue.elements[ pixelIndex - rayCount ] = pixelHash;
+
+				}
+
+			}
+		`;
+
+		super( fn( params ) );
+
+		this.defineUniformAccessors( params );
+
+	}
+
+}

package/src/webgpu/compute/wavefront/QueueLengthToDispatchKernel.js

@@ -0,0 +1,38 @@
+import { IndirectStorageBufferAttribute, StorageBufferAttribute } from 'three/webgpu';
+import { storage } from 'three/tsl';
+import { ComputeKernel } from '../ComputeKernel.js';
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { rayQueueAtomicStruct } from './structs.js';
+
+// Converts a queue's atomic length counter into indirect dispatch arguments so the trace kernels can
+// be dispatched with exactly as many threads as there are queued rays.
+export class QueueLengthToDispatchKernel extends ComputeKernel {
+
+	constructor( queueStruct = rayQueueAtomicStruct, workgroupSize = 64 ) {
+
+		const params = {
+			queue: storage( new StorageBufferAttribute( 1, 1 ), queueStruct ),
+			outputDispatch: storage( new IndirectStorageBufferAttribute( 3, 1 ), 'u32' ).setName( 'outputDispatch' ),
+		};
+
+		const fn = wgslTagFn/* wgsl */`
+			fn compute() -> void {
+
+				let queue = &${ params.queue };
+				let outputDispatch = &${ params.outputDispatch };
+
+				let queueLength = atomicLoad( &queue.length );
+				outputDispatch[ 0 ] = ( queueLength + ${ workgroupSize - 1 }u ) / ${ workgroupSize }u;
+				outputDispatch[ 1 ] = 1u;
+				outputDispatch[ 2 ] = 1u;
+
+			}
+		`;
+
+		super( fn( params ) );
+
+		this.defineUniformAccessors( params );
+
+	}
+
+}

package/src/webgpu/compute/wavefront/ResetSlotsKernel.js

@@ -0,0 +1,66 @@
+import { StorageBufferAttribute } from 'three/webgpu';
+import { uniform, storage, globalId } from 'three/tsl';
+import { ComputeKernel } from '../ComputeKernel.js';
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { rayDataStruct, pixelQueueStruct } from './structs.js';
+
+// Moves pixels between a range of path slots and the queue when the pool is resized. Slots added
+// by a grow take a pixel from the queue tail and start idle, as MaterialKernel expects. Slots
+// dropped by a shrink push their pixel onto the tail before the pool is discarded. Runs between
+// frames, so nothing else touches the queue meanwhile.
+export class ResetSlotsKernel extends ComputeKernel {
+
+	constructor( ) {
+
+		const params = {
+			rayDataStorage: storage( new StorageBufferAttribute( 1, 1 ), rayDataStruct ),
+			pixelQueue: storage( new StorageBufferAttribute( 1, 1 ), pixelQueueStruct ),
+			start: uniform( 0, 'uint' ),
+			end: uniform( 0, 'uint' ),
+			addingSlots: uniform( 0, 'uint' ),
+			globalId: globalId,
+		};
+
+		const fn = wgslTagFn/* wgsl */`
+			fn compute( start: u32, end: u32, addingSlots: u32, globalId: vec3u ) -> void {
+
+				let rayDataStorage = &${ params.rayDataStorage };
+				let pixelQueue = &${ params.pixelQueue };
+
+				let index = start + globalId.x;
+				if ( index >= end ) {
+
+					return;
+
+				}
+
+				if ( addingSlots == 0u ) {
+
+					// slots being removed hand their pixel back before the pool is discarded
+					let queueIndex = atomicAdd( &pixelQueue.elementCount, 1u );
+					atomicStore( &pixelQueue.elements[ queueIndex ], rayDataStorage[ index ].pixelIndex );
+
+				} else {
+
+					// the pool never exceeds the pixel count, so the queue holds enough for every new slot
+					let previousCount = atomicSub( &pixelQueue.elementCount, 1u );
+					rayDataStorage[ index ].pixelIndex = atomicLoad( &pixelQueue.elements[ previousCount - 1u ] );
+					rayDataStorage[ index ].resultColor = vec4f( 0.0 );
+					rayDataStorage[ index ].throughputColor = vec3f( 0.0 );
+					rayDataStorage[ index ].objectIndex = - 1;
+					rayDataStorage[ index ].alphaDepth = 0u;
+					rayDataStorage[ index ].rayIntersectionIndex = - 1;
+					rayDataStorage[ index ].shadowRayIntersectionIndex = - 1;
+
+				}
+
+			}
+		`;
+
+		super( fn( params ) );
+
+		this.defineUniformAccessors( params );
+
+	}
+
+}

package/src/webgpu/compute/wavefront/TraceRayKernel.js

@@ -0,0 +1,71 @@
+import { StorageBufferAttribute } from 'three/webgpu';
+import { ComputeKernel } from '../ComputeKernel.js';
+import { storage, globalId } from 'three/tsl';
+import { proxy, wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { rngInit } from '../../nodes/random.wgsl.js';
+import { rayQueueStruct, intersectionResultStruct } from './structs.js';
+
+// Pure BVH traversal over the queued bounce rays: one thread per queued ray, writing a compact
+// intersection result at the ray's queue index for LogicKernel to consume next frame.
+export class TraceRayKernel extends ComputeKernel {
+
+	constructor( ) {
+
+		const params = {
+			bvhData: { value: null },
+
+			rayQueue: storage( new StorageBufferAttribute( 1, 1 ), rayQueueStruct ),
+			rayIntersectionsStorage: storage( new StorageBufferAttribute( 1, 1 ), intersectionResultStruct ),
+
+			globalId: globalId,
+		};
+
+		const raycastOutput = proxy( 'bvhData.value.fns.raycastFirstHit.outputType', params );
+		const raycastFirstHitFn = proxy( 'bvhData.value.fns.raycastFirstHit', params );
+
+		const fn = wgslTagFn /* wgsl */`
+
+			fn compute( globalId: vec3u ) -> void {
+
+				let rayQueue = &${ params.rayQueue };
+				let rayIntersectionsStorage = &${ params.rayIntersectionsStorage };
+
+				let index = globalId.x;
+				if ( index >= rayQueue.length ) {
+
+					return;
+
+				}
+
+				let queuedRay = ( *rayQueue ).elements[ index ];
+				let indexUV = vec2u( queuedRay.pixelIndex >> 16, queuedRay.pixelIndex & 0xFFFF );
+				${ rngInit }( indexUV, queuedRay.seed, queuedRay.currentBounce + queuedRay.alphaDepth );
+
+				let ray = Ray( queuedRay.origin, queuedRay.direction, queuedRay.maxDist );
+				var hitResult: ${ raycastOutput };
+				if ( ${ raycastFirstHitFn }( ray, &hitResult ) ) {
+
+					rayIntersectionsStorage[ index ].barycoord = hitResult.barycoord;
+					rayIntersectionsStorage[ index ].objectIndex = i32( hitResult.objectIndex );
+					rayIntersectionsStorage[ index ].position = ray.origin + ray.direction * hitResult.dist;
+					rayIntersectionsStorage[ index ].dist = hitResult.dist;
+					rayIntersectionsStorage[ index ].normal = hitResult.normal.xyz;
+					rayIntersectionsStorage[ index ].side = hitResult.side;
+					rayIntersectionsStorage[ index ].indices = hitResult.indices.xyz;
+
+				} else {
+
+					rayIntersectionsStorage[ index ].objectIndex = - 1;
+
+				}
+
+			}
+		`;
+
+		super( fn( params ) );
+
+		this.defineUniformAccessors( params );
+
+	}
+
+}

package/src/webgpu/compute/wavefront/TraceShadowRayKernel.js

@@ -0,0 +1,67 @@
+import { StorageBufferAttribute } from 'three/webgpu';
+import { ComputeKernel } from '../ComputeKernel.js';
+import { storage, globalId } from 'three/tsl';
+import { proxy, wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { rngInit } from '../../nodes/random.wgsl.js';
+import { rayQueueStruct, intersectionResultStruct } from './structs.js';
+
+// Pure BVH traversal over the queued shadow rays. Uses the same first-hit traversal as the bounce
+// rays ( no dedicated any-hit traversal exists yet ); LogicKernel decides occlusion by comparing the
+// hit distance against the light distance.
+export class TraceShadowRayKernel extends ComputeKernel {
+
+	constructor( ) {
+
+		const params = {
+			bvhData: { value: null },
+
+			shadowRayQueue: storage( new StorageBufferAttribute( 1, 1 ), rayQueueStruct ),
+			shadowRayIntersectionsStorage: storage( new StorageBufferAttribute( 1, 1 ), intersectionResultStruct ),
+
+			globalId: globalId,
+		};
+
+		const raycastOutput = proxy( 'bvhData.value.fns.raycastFirstHit.outputType', params );
+		const raycastFirstHitFn = proxy( 'bvhData.value.fns.raycastFirstHit', params );
+
+		const fn = wgslTagFn /* wgsl */`
+
+			fn compute( globalId: vec3u ) -> void {
+
+				let shadowRayQueue = &${ params.shadowRayQueue };
+				let shadowRayIntersectionsStorage = &${ params.shadowRayIntersectionsStorage };
+
+				let index = globalId.x;
+				if ( index >= shadowRayQueue.length ) {
+
+					return;
+
+				}
+
+				let queuedRay = ( *shadowRayQueue ).elements[ index ];
+				let indexUV = vec2u( queuedRay.pixelIndex >> 16, queuedRay.pixelIndex & 0xFFFF );
+				${ rngInit }( indexUV, queuedRay.seed, queuedRay.currentBounce + queuedRay.alphaDepth );
+
+				let ray = Ray( queuedRay.origin, queuedRay.direction, queuedRay.maxDist );
+				var hitResult: ${ raycastOutput };
+				if ( ${ raycastFirstHitFn }( ray, &hitResult ) ) {
+
+					shadowRayIntersectionsStorage[ index ].objectIndex = i32( hitResult.objectIndex );
+					shadowRayIntersectionsStorage[ index ].dist = hitResult.dist;
+
+				} else {
+
+					shadowRayIntersectionsStorage[ index ].objectIndex = - 1;
+
+				}
+
+			}
+		`;
+
+		super( fn( params ) );
+
+		this.defineUniformAccessors( params );
+
+	}
+
+}