three-gpu-pathtracer 0.0.27 → 0.0.28

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

@@ -0,0 +1,154 @@
+import { StorageBufferAttribute } from 'three/webgpu';
+import { ComputeKernel } from '../ComputeKernel.js';
+import { storage, uniform, globalId } from 'three/tsl';
+import { contextProxy, wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { rngInit, rngNextBounce, rand2, RNG_INDEX_MEDIUM_DISTANCE, RNG_INDEX_MEDIUM_DIRECTION } from '../../nodes/random.wgsl.js';
+import { LIGHT_FAR_DISTANCE } from '../../nodes/lights.wgsl.js';
+import { sampleHenyeyGreensteinFn } from '../../nodes/sampling.wgsl.js';
+import {
+	loadMediumFn,
+	mediumChannelPdfFn, sampleMediumDistanceFn, mediumDistancePdfFn,
+	MEDIUM_THROUGHPUT_EPSILON,
+} from '../../nodes/medium.wgsl.js';
+import { rayDataStruct, intersectionResultStruct, MEDIUM_QUEUE_LENGTH, MEDIUM_QUEUE_HEADER } from './structs.js';
+
+// Random walks through scattering media, as in Cycles' subsurface kernel but capped per pass. A walk that
+// reaches a surface hands its hit to LogicKernel like a traced ray, one that doesn't resumes next pass. The
+// walk's weight goes into the staged scatter color.
+export class MediumKernel extends ComputeKernel {
+
+	constructor( ) {
+
+		const params = {
+			maxSubsurfaceBounces: uniform( 256, 'uint' ),
+			stepsPerPass: uniform( 16, 'uint' ),
+			rayCount: uniform( 0, 'uint' ),
+
+			rayDataStorage: storage( new StorageBufferAttribute( 1, 1 ), rayDataStruct ),
+			mediumQueue: storage( new StorageBufferAttribute( 1, 1 ), 'uint' ),
+			rayIntersectionsStorage: storage( new StorageBufferAttribute( 1, 1 ), intersectionResultStruct ),
+
+			globalId: globalId,
+		};
+
+		const raycastOutput = contextProxy( 'bvhData.fns.raycastFirstHit.outputType' );
+		const raycastFirstHitFn = contextProxy( 'bvhData.fns.raycastFirstHit' );
+
+		const fn = wgslTagFn/* wgsl */`
+
+			fn compute( maxSubsurfaceBounces: u32, stepsPerPass: u32, rayCount: u32, globalId: vec3u ) -> void {
+
+				let rayDataStorage = &${ params.rayDataStorage };
+				let mediumQueue = &${ params.mediumQueue };
+				let rayIntersectionsStorage = &${ params.rayIntersectionsStorage };
+
+				if ( globalId.x >= mediumQueue[ ${ MEDIUM_QUEUE_LENGTH }u ] ) {
+
+					return;
+
+				}
+
+				let index = mediumQueue[ ${ MEDIUM_QUEUE_HEADER }u + globalId.x ];
+				// whole structs are read from the buffer, not the pointer alias, which Safari fails to compile
+				let input = ${ params.rayDataStorage }[ index ];
+				let medium = ${ loadMediumFn }( input.medium );
+
+				let indexUV = vec2u( input.pixelIndex >> 16, input.pixelIndex & 0xFFFF );
+				${ rngInit }( indexUV, input.seed, input.currentBounce + input.alphaDepth + input.subsurfaceBounces );
+
+				var ray = Ray( input.origin, input.direction, 0.0 );
+				var weight = input.scatterColor;
+				var subsurfaceBounces = input.subsurfaceBounces;
+				var hasScattered = false;
+				var isFinished = false;
+				var isTerminated = false;
+
+				for ( var i = 0u; i < stepsPerPass; i ++ ) {
+
+					// only trace up to the sampled scatter event
+					let channelPdf = ${ mediumChannelPdfFn }( input.throughputColor * weight, medium.albedo );
+					let scatterDist = ${ sampleMediumDistanceFn }( medium, channelPdf, ${ rand2 }( ${ RNG_INDEX_MEDIUM_DISTANCE } ) );
+					ray.maxDist = scatterDist;
+
+					var hitResult: ${ raycastOutput };
+					let didHit = ${ raycastFirstHitFn }( ray, &hitResult );
+					let surfaceDist = select( ${ LIGHT_FAR_DISTANCE }, hitResult.dist, didHit );
+
+					let scattered = scatterDist < surfaceDist;
+					let segmentDist = select( surfaceDist, scatterDist, scattered );
+					let transmittance = exp( - medium.extinction * segmentDist );
+					let distancePdf = dot( channelPdf, ${ mediumDistancePdfFn }( medium, segmentDist, scattered ) );
+					if ( distancePdf <= 0.0 ) {
+
+						isTerminated = true;
+						break;
+
+					}
+
+					if ( ! scattered ) {
+
+						// reaching the surface, weighted by the chance of not scattering before it
+						weight *= transmittance / distancePdf;
+
+						// The hit fills the ray results from the back, by the walk's medium queue position, while the
+						// traced rays fill them from the front. A path slot walking a medium queued no ray this round,
+						// so the two ranges never exceed the slot count or overlap
+						let resultIndex = rayCount - 1u - globalId.x;
+						rayIntersectionsStorage[ resultIndex ].barycoord = hitResult.barycoord;
+						// a walk that leaves without hitting anything is a miss, as in the trace kernel
+						rayIntersectionsStorage[ resultIndex ].objectIndex = select( - 1, i32( hitResult.objectIndex ), didHit );
+						rayIntersectionsStorage[ resultIndex ].position = ray.origin + ray.direction * hitResult.dist;
+						rayIntersectionsStorage[ resultIndex ].dist = hitResult.dist;
+						rayIntersectionsStorage[ resultIndex ].normal = hitResult.normal.xyz;
+						rayIntersectionsStorage[ resultIndex ].side = hitResult.side;
+						rayIntersectionsStorage[ resultIndex ].indices = hitResult.indices.xyz;
+						rayDataStorage[ index ].rayIntersectionIndex = i32( resultIndex );
+
+						isFinished = true;
+						break;
+
+					}
+
+					weight *= medium.albedo * medium.extinction * transmittance / distancePdf;
+					ray.origin += ray.direction * scatterDist;
+					ray.direction = ${ sampleHenyeyGreensteinFn }( ray.direction, medium.anisotropy, ${ rand2 }( ${ RNG_INDEX_MEDIUM_DIRECTION } ) );
+					hasScattered = true;
+
+					// capped separately from bounces, and ends once the throughput is negligible
+					subsurfaceBounces ++;
+					let throughput = input.throughputColor * weight / input.scatterPdf;
+					if ( subsurfaceBounces >= maxSubsurfaceBounces || max( max( throughput.r, throughput.g ), throughput.b ) < ${ MEDIUM_THROUGHPUT_EPSILON } ) {
+
+						isTerminated = true;
+						break;
+
+					}
+
+					${ rngNextBounce }();
+
+				}
+
+				// a zeroed pdf terminates the path in LogicKernel
+				rayDataStorage[ index ].scatterColor = weight;
+				rayDataStorage[ index ].scatterPdf = select( input.scatterPdf, 0.0, isTerminated );
+				rayDataStorage[ index ].origin = ray.origin;
+				rayDataStorage[ index ].direction = ray.direction;
+				rayDataStorage[ index ].subsurfaceBounces = subsurfaceBounces;
+				rayDataStorage[ index ].walkPending = select( 1u, 0u, isFinished || isTerminated );
+				if ( hasScattered ) {
+
+					rayDataStorage[ index ].mediumScattered = 1u;
+					rayDataStorage[ index ].isFullyTransmissive = 0u;
+
+				}
+
+			}
+		`;
+
+		super( fn( params ) );
+
+		this.defineUniformAccessors( params );
+
+	}
+
+}

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

@@ -3,7 +3,7 @@ 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';
+import { rayDataStruct, PIXEL_QUEUE_CURRENT, PIXEL_QUEUE_ELEMENT_COUNT, PIXEL_QUEUE_HEADER } 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
@@ -15,7 +15,7 @@ export class PopulatePixelIndicesKernel extends ComputeKernel {
 
 		const params = {
 			rayDataStorage: storage( new StorageBufferAttribute( 1, 1 ), rayDataStruct ),
-			pixelQueue: storage( new StorageBufferAttribute( 1, 1 ), pixelQueueNonAtomicStruct ),
+			pixelQueue: storage( new StorageBufferAttribute( 1, 1 ), 'uint' ),
 			targetDimensions: uniform( new Vector2() ),
 			frameBudget: uniform( 0, 'uint' ),
 			globalId: globalId,
@@ -37,8 +37,8 @@ export class PopulatePixelIndicesKernel extends ComputeKernel {
 				let pixelCount = targetDimensions.x * targetDimensions.y;
 				if ( globalId.x == 0u && globalId.y == 0u ) {
 
-					pixelQueue.current = 0u;
-					pixelQueue.elementCount = select( 0u, pixelCount - rayCount, pixelCount >= rayCount );
+					pixelQueue[ ${ PIXEL_QUEUE_CURRENT }u ] = 0u;
+					pixelQueue[ ${ PIXEL_QUEUE_ELEMENT_COUNT }u ] = select( 0u, pixelCount - rayCount, pixelCount >= rayCount );
 
 				}
 
@@ -56,7 +56,7 @@ export class PopulatePixelIndicesKernel extends ComputeKernel {
 
 				} else {
 
-					pixelQueue.elements[ pixelIndex - rayCount ] = pixelHash;
+					pixelQueue[ ${ PIXEL_QUEUE_HEADER }u + pixelIndex - rayCount ] = pixelHash;
 
 				}
 

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

@@ -2,26 +2,26 @@ import { IndirectStorageBufferAttribute, StorageBufferAttribute } from 'three/we
 import { storage } from 'three/tsl';
 import { ComputeKernel } from '../ComputeKernel.js';
 import { wgslTagFn } from 'three-mesh-bvh/webgpu';
-import { rayQueueAtomicStruct } from './structs.js';
+import { RAY_QUEUE_LENGTH } 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 ) {
+	constructor( counterIndex = RAY_QUEUE_LENGTH, workgroupSize = 64 ) {
 
 		const params = {
-			queue: storage( new StorageBufferAttribute( 1, 1 ), queueStruct ),
+			queueCounters: storage( new StorageBufferAttribute( 1, 1 ), 'uint' ).toAtomic(),
 			outputDispatch: storage( new IndirectStorageBufferAttribute( 3, 1 ), 'u32' ).setName( 'outputDispatch' ),
 		};
 
 		const fn = wgslTagFn/* wgsl */`
 			fn compute() -> void {
 
-				let queue = &${ params.queue };
+				let queueCounters = &${ params.queueCounters };
 				let outputDispatch = &${ params.outputDispatch };
 
-				let queueLength = atomicLoad( &queue.length );
+				let queueLength = atomicLoad( &queueCounters[ ${ counterIndex }u ] );
 				outputDispatch[ 0 ] = ( queueLength + ${ workgroupSize - 1 }u ) / ${ workgroupSize }u;
 				outputDispatch[ 1 ] = 1u;
 				outputDispatch[ 2 ] = 1u;

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

@@ -0,0 +1,52 @@
+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, MEDIUM_QUEUE_LENGTH, MEDIUM_QUEUE_HEADER } from './structs.js';
+
+// Gathers the path slots walking a medium for MediumKernel's dispatch. Separate from MaterialKernel, which
+// is at its storage buffer limit.
+export class QueueMediumWalksKernel extends ComputeKernel {
+
+	constructor( ) {
+
+		const params = {
+			rayCount: uniform( 0, 'uint' ),
+
+			rayDataStorage: storage( new StorageBufferAttribute( 1, 1 ), rayDataStruct ).toReadOnly(),
+			mediumQueue: storage( new StorageBufferAttribute( 1, 1 ), 'uint' ).toAtomic(),
+
+			globalId: globalId,
+		};
+
+		const fn = wgslTagFn/* wgsl */`
+
+			fn compute( rayCount: u32, globalId: vec3u ) -> void {
+
+				let rayDataStorage = &${ params.rayDataStorage };
+				let mediumQueue = &${ params.mediumQueue };
+
+				let index = globalId.x;
+				if ( index >= rayCount ) {
+
+					return;
+
+				}
+
+				if ( rayDataStorage[ index ].walkPending != 0u && rayDataStorage[ index ].objectIndex >= 0 ) {
+
+					let queueIndex = atomicAdd( &mediumQueue[ ${ MEDIUM_QUEUE_LENGTH }u ], 1u );
+					atomicStore( &mediumQueue[ ${ MEDIUM_QUEUE_HEADER }u + queueIndex ], index );
+
+				}
+
+			}
+		`;
+
+		super( fn( params ) );
+
+		this.defineUniformAccessors( params );
+
+	}
+
+}

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

@@ -2,7 +2,7 @@ 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';
+import { rayDataStruct, PIXEL_QUEUE_ELEMENT_COUNT, PIXEL_QUEUE_HEADER } 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
@@ -14,7 +14,7 @@ export class ResetSlotsKernel extends ComputeKernel {
 
 		const params = {
 			rayDataStorage: storage( new StorageBufferAttribute( 1, 1 ), rayDataStruct ),
-			pixelQueue: storage( new StorageBufferAttribute( 1, 1 ), pixelQueueStruct ),
+			pixelQueue: storage( new StorageBufferAttribute( 1, 1 ), 'uint' ).toAtomic(),
 			start: uniform( 0, 'uint' ),
 			end: uniform( 0, 'uint' ),
 			addingSlots: uniform( 0, 'uint' ),
@@ -37,14 +37,14 @@ export class ResetSlotsKernel extends ComputeKernel {
 				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 );
+					let queueIndex = atomicAdd( &pixelQueue[ ${ PIXEL_QUEUE_ELEMENT_COUNT }u ], 1u );
+					atomicStore( &pixelQueue[ ${ PIXEL_QUEUE_HEADER }u + 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 ] );
+					let previousCount = atomicSub( &pixelQueue[ ${ PIXEL_QUEUE_ELEMENT_COUNT }u ], 1u );
+					rayDataStorage[ index ].pixelIndex = atomicLoad( &pixelQueue[ ${ PIXEL_QUEUE_HEADER }u + previousCount - 1u ] );
 					rayDataStorage[ index ].resultColor = vec4f( 0.0 );
 					rayDataStorage[ index ].throughputColor = vec3f( 0.0 );
 					rayDataStorage[ index ].objectIndex = - 1;

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

@@ -1,9 +1,9 @@
 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 { contextProxy, wgslTagFn } from 'three-mesh-bvh/webgpu';
 import { rngInit } from '../../nodes/random.wgsl.js';
-import { rayQueueStruct, intersectionResultStruct } from './structs.js';
+import { traceQueuedRayStruct, intersectionResultStruct, RAY_QUEUE_LENGTH } 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.
@@ -12,34 +12,36 @@ export class TraceRayKernel extends ComputeKernel {
 	constructor( ) {
 
 		const params = {
-			bvhData: { value: null },
 
-			rayQueue: storage( new StorageBufferAttribute( 1, 1 ), rayQueueStruct ),
+			rayQueue: storage( new StorageBufferAttribute( 1, 1 ), traceQueuedRayStruct ),
+			queueCounters: storage( new StorageBufferAttribute( 1, 1 ), 'uint' ),
 			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 raycastOutput = contextProxy( 'bvhData.fns.raycastFirstHit.outputType' );
+		const raycastFirstHitFn = contextProxy( 'bvhData.fns.raycastFirstHit' );
 
 		const fn = wgslTagFn /* wgsl */`
 
 			fn compute( globalId: vec3u ) -> void {
 
 				let rayQueue = &${ params.rayQueue };
+				let queueCounters = &${ params.queueCounters };
 				let rayIntersectionsStorage = &${ params.rayIntersectionsStorage };
 
 				let index = globalId.x;
-				if ( index >= rayQueue.length ) {
+				if ( index >= queueCounters[ ${ RAY_QUEUE_LENGTH }u ] ) {
 
 					return;
 
 				}
 
-				let queuedRay = ( *rayQueue ).elements[ index ];
+				// whole structs are read from the buffer, not the pointer alias, which Safari fails to compile
+				let queuedRay = ${ params.rayQueue }[ index ];
 				let indexUV = vec2u( queuedRay.pixelIndex >> 16, queuedRay.pixelIndex & 0xFFFF );
-				${ rngInit }( indexUV, queuedRay.seed, queuedRay.currentBounce + queuedRay.alphaDepth );
+				${ rngInit }( indexUV, queuedRay.seed, queuedRay.rngIndex );
 
 				let ray = Ray( queuedRay.origin, queuedRay.direction, queuedRay.maxDist );
 				var hitResult: ${ raycastOutput };

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

@@ -1,61 +1,54 @@
 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 { contextProxy, wgslTagFn } from 'three-mesh-bvh/webgpu';
 import { rngInit } from '../../nodes/random.wgsl.js';
-import { rayQueueStruct, intersectionResultStruct } from './structs.js';
+import { traceQueuedRayStruct, shadowTraceResultStruct, SHADOW_RAY_QUEUE_LENGTH } from './structs.js';
 
-// Pure BVH traversal over the queued shadow rays. Uses a first-hit traversal without face culling
-// ( no dedicated any-hit traversal exists yet ); LogicKernel decides occlusion by comparing the
-// hit distance against the light distance.
+// Pure BVH traversal over the queued shadow rays. Uses an any-hit traversal without face culling that
+// passes partially transparent surfaces, accumulating the light they block.
 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 ),
+			shadowRayQueue: storage( new StorageBufferAttribute( 1, 1 ), traceQueuedRayStruct ),
+			queueCounters: storage( new StorageBufferAttribute( 1, 1 ), 'uint' ),
+			shadowRayIntersectionsStorage: storage( new StorageBufferAttribute( 1, 1 ), shadowTraceResultStruct ),
 
 			globalId: globalId,
 		};
 
-		const raycastOutput = proxy( 'bvhData.value.fns.raycastFirstHit.outputType', params );
-		const raycastShadowFn = proxy( 'bvhData.value.fns.raycastShadow', params );
+		const raycastOutput = contextProxy( 'bvhData.fns.raycastFirstHit.outputType' );
+		const raycastShadowFn = contextProxy( 'bvhData.fns.raycastShadow' );
 
 		const fn = wgslTagFn /* wgsl */`
 
 			fn compute( globalId: vec3u ) -> void {
 
 				let shadowRayQueue = &${ params.shadowRayQueue };
+				let queueCounters = &${ params.queueCounters };
 				let shadowRayIntersectionsStorage = &${ params.shadowRayIntersectionsStorage };
 
 				let index = globalId.x;
-				if ( index >= shadowRayQueue.length ) {
+				if ( index >= queueCounters[ ${ SHADOW_RAY_QUEUE_LENGTH }u ] ) {
 
 					return;
 
 				}
 
-				let queuedRay = ( *shadowRayQueue ).elements[ index ];
+				// whole structs are read from the buffer, not the pointer alias, which Safari fails to compile
+				let queuedRay = ${ params.shadowRayQueue }[ index ];
 				let indexUV = vec2u( queuedRay.pixelIndex >> 16, queuedRay.pixelIndex & 0xFFFF );
-				${ rngInit }( indexUV, queuedRay.seed, queuedRay.currentBounce + queuedRay.alphaDepth );
+				${ rngInit }( indexUV, queuedRay.seed, queuedRay.rngIndex );
 
 				let ray = Ray( queuedRay.origin, queuedRay.direction, queuedRay.maxDist );
 				var hitResult: ${ raycastOutput };
-				if ( ${ raycastShadowFn }( ray, &hitResult ) ) {
-
-					shadowRayIntersectionsStorage[ index ].objectIndex = i32( hitResult.objectIndex );
-					shadowRayIntersectionsStorage[ index ].dist = hitResult.dist;
-
-				} else {
-
-					shadowRayIntersectionsStorage[ index ].objectIndex = - 1;
-
-				}
-
-				shadowRayIntersectionsStorage[ index ].forwardBlocked = u32( hitResult.forwardBlocked );
+				let occluded = ${ raycastShadowFn }( ray, &hitResult );
+				shadowRayIntersectionsStorage[ index ].objectIndex = select( - 1, i32( hitResult.objectIndex ), occluded );
+				shadowRayIntersectionsStorage[ index ].skippedOcclusion = hitResult.skippedOcclusion;
+				shadowRayIntersectionsStorage[ index ].occlusion = hitResult.occlusion;
 
 			}
 		`;

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

@@ -1,4 +1,5 @@
 import { StructTypeNode } from 'three/webgpu';
+import { mediumStateStruct } from '../../nodes/medium.wgsl.js';
 
 // StructTypeNode that force-emits dependency structs. TSL can't discover a struct referenced only via
 // a type string, so we build each dependency first, which registers its definition ahead of this struct.
@@ -28,7 +29,7 @@ class DependentStructTypeNode extends StructTypeNode {
 
 // Persistent per-path-slot state. One slot per in-flight path, holding everything needed to resolve
 // the previous frame's trace results and stage the next bounce.
-export const rayDataStruct = new StructTypeNode( {
+const rayDataMembers = {
 
 	throughputColor: 'vec3f',
 	currentBounce: 'uint',
@@ -76,8 +77,10 @@ export const rayDataStruct = new StructTypeNode( {
 	// the traced segment length, for the transmission attenuation applied by MaterialKernel
 	dist: 'float',
 
-	// alpha test pass throughs, counted separately from the bounce count
+	// alpha test pass throughs, counted separately from the bounce count, and how far along the ray they
+	// moved the start of its traversal. The ray keeps the origin it scattered from
 	alphaDepth: 'uint',
+	rayStart: 'float',
 
 	// the camera segment's maximum trace distance, carried across alpha pass throughs
 	maxDist: 'float',
@@ -86,7 +89,30 @@ export const rayDataStruct = new StructTypeNode( {
 	// first dispersive interaction
 	dispersionWavelength: 'float',
 
-}, 'RayData' );
+	// the first scatter's albedo and normal, 8 bits per channel, for the denoiser's auxiliary buffers
+	auxAlbedo: 'uint',
+	auxNormal: 'uint',
+
+	// scatter events taken inside media, counted separately from the bounce count
+	subsurfaceBounces: 'uint',
+
+	// whether MediumKernel walks the path's next segment, cleared once the walk reaches a surface or ends
+	walkPending: 'uint',
+
+	// whether the staged segment starts at a medium scatter event, where no light is sampled
+	mediumScattered: 'uint',
+
+};
+
+// The path's medium, nested at the end to share the ray data buffer under the storage buffer limit. Sized
+// separately since nested structs aren't.
+export const rayDataStruct = new DependentStructTypeNode( {
+	...rayDataMembers,
+	medium: mediumStateStruct.name,
+}, 'RayData', [ mediumStateStruct ] );
+
+const rayDataLength = new StructTypeNode( rayDataMembers ).getLength();
+rayDataStruct.getLength = () => rayDataLength + mediumStateStruct.getLength();
 
 // A ray queued for BVH traversal by the trace kernels. A "maxDist" of zero traces unbounded.
 export const traceQueuedRayStruct = new StructTypeNode( {
@@ -95,12 +121,14 @@ export const traceQueuedRayStruct = new StructTypeNode( {
 	pixelIndex: 'uint',
 
 	direction: 'vec3f',
-	currentBounce: 'uint',
+
+	// the traversal's random sequence index: bounces, alpha pass throughs and subsurface bounces, as in the megakernel
+	rngIndex: 'uint',
 
 	seed: 'uint',
-	alphaDepth: 'uint',
 	maxDist: 'float',
 	_alignment0: 'uint',
+	_alignment1: 'uint',
 
 }, 'TraceQueuedRay' );
 
@@ -119,39 +147,37 @@ export const intersectionResultStruct = new StructTypeNode( {
 
 	indices: 'vec3u',
 
-	// shadow rays only: a face a bsdf ray would hit was passed
-	forwardBlocked: 'uint',
-
 }, 'TraceResult' );
 
-// Queue wrappers that keep an append-only length counter in a header ahead of the elements. The
-// atomic variant is bound where rays are pushed with atomicAdd; the plain one where the length is
-// only read or reset. getLength returns just the header since the trailing array is runtime-sized.
-export const rayQueueStruct = new DependentStructTypeNode( {
-	length: 'uint',
-	elements: `array<${ traceQueuedRayStruct.name }>`,
-}, 'RayQueue', [ traceQueuedRayStruct ] );
-rayQueueStruct.getLength = () => 4;
-
-export const rayQueueAtomicStruct = new DependentStructTypeNode( {
-	length: { type: 'uint', atomic: true },
-	elements: `array<${ traceQueuedRayStruct.name }>`,
-}, 'RayQueue', [ traceQueuedRayStruct ] );
-rayQueueAtomicStruct.getLength = () => 4;
+// Shadow ray trace result, written by TraceShadowRayKernel at the ray's queue index and consumed by
+// LogicKernel the following frame. objectIndex >= 0 encodes an occluded light.
+export const shadowTraceResultStruct = new StructTypeNode( {
+
+	objectIndex: 'int',
+
+	// the share of bsdf rays the skipped faces would stop, whose light weight moves to the light sample
+	skippedOcclusion: 'float',
+
+	// the fraction of light blocked by the partially transparent surfaces passed
+	occlusion: 'float',
+
+}, 'ShadowTraceResult' );
+
+// The ray and shadow ray queues are plain arrays of queued rays, with their append-only lengths in a
+// separate counters buffer: storage buffers are always bound as arrays, which can't hold a struct
+// ending in a runtime-sized array.
+export const RAY_QUEUE_LENGTH = 0;
+export const SHADOW_RAY_QUEUE_LENGTH = 1;
+export const QUEUE_COUNTER_COUNT = 2;
+
+// The path slots walking through a medium this pass, for MediumKernel. Its length leads the same u32
+// array, ahead of the elements, as MediumKernel is at its storage buffer limit.
+export const MEDIUM_QUEUE_LENGTH = 0;
+export const MEDIUM_QUEUE_HEADER = 1;
 
 // Round-robin queue of pixel indices waiting for a free path slot when the output resolution exceeds
-// the ray data pool. Sized to the pixel count so retiring slots can always return their pixel. The
-// non-atomic variant is used for contention-free initialization.
-export const pixelQueueStruct = new DependentStructTypeNode( {
-	current: { type: 'uint', atomic: true },
-	elementCount: { type: 'uint', atomic: true },
-	elements: 'array<atomic<u32>>',
-}, 'PixelQueue' );
-pixelQueueStruct.getLength = () => 2;
-
-export const pixelQueueNonAtomicStruct = new DependentStructTypeNode( {
-	current: 'uint',
-	elementCount: 'uint',
-	elements: 'array<u32>',
-}, 'PixelQueue' );
-pixelQueueNonAtomicStruct.getLength = () => 2;
+// the ray data pool, sized to the pixel count so retiring slots can always return their pixel. Its
+// counters lead the same u32 array, ahead of the elements.
+export const PIXEL_QUEUE_CURRENT = 0;
+export const PIXEL_QUEUE_ELEMENT_COUNT = 1;
+export const PIXEL_QUEUE_HEADER = 2;

package/src/webgpu/constants.js

@@ -13,7 +13,7 @@ import * as bluedither from './nodes/rand/bluedither.wgsl.js';
 export const RANDOM_PCG = pcg;
 
 /**
- * Sobol low discrepancy samples, scrambled per pixel. Converges faster than `RANDOM_PCG`.
+ * Sobol low discrepancy samples, scrambled per pixel. Converges faster than `RANDOM_PCG`. The default.
  * @section Random Strategies
  * @type {Object}
  */
@@ -21,7 +21,7 @@ export const RANDOM_SOBOL = sobol;
 
 /**
  * The same Sobol sequence for every pixel, offset by a blue noise dither so early frames read as
- * smooth grain rather than clumped noise. The default.
+ * smooth grain rather than clumped noise.
  * @section Random Strategies
  * @type {Object}
  */