three-gpu-pathtracer 0.0.27 → 0.0.28

package/src/webgpu/denoise/OIDNDenoiser.js

@@ -1,8 +1,20 @@
-import { ExternalTexture, NearestFilter, NoToneMapping, RenderTarget, UnsignedByteType } from 'three/webgpu';
-import { diffuseColor, mrt, normalView, vec4 } from 'three/tsl';
+import { EventDispatcher, ExternalTexture } from 'three/webgpu';
+import { UnpackAuxKernel } from '../compute/UnpackAuxKernel.js';
+import { createAuxImageTarget } from '../compute/targets.js';
 
-/** @import { Camera, Scene, Texture, WebGPURenderer } from 'three/webgpu' */
-/** @import { DynamicTileSetting } from 'oidn-web' */
+/** @import { StorageArrayTexture, Texture, WebGPURenderer } from 'three/webgpu' */
+/** @import { DynamicTileSetting } from 'oidn-webgpu' */
+
+/**
+ * Fired when a pass started by `update` fails, such as the weights failing to download, with the
+ * failure as the event's `error`. No other pass starts until a reset.
+ * @event OIDNDenoiser#error
+ */
+
+/**
+ * Fired as each tile of a pass finishes, with the fraction of the pass done as `progress`.
+ * @event OIDNDenoiser#progress
+ */
 
 /**
  * Runs Open Image Denoise over a path traced image. Pass one to
@@ -12,14 +24,14 @@ import { diffuseColor, mrt, normalView, vec4 } from 'three/tsl';
  * nor the network files become a dependency.
  *
  * ```js
- * import { initUNetFromURL } from 'oidn-web';
+ * import { initUNetFromURL } from 'oidn-webgpu';
  * pathTracer.setDenoiser( new OIDNDenoiser( { initUNetFromURL, auxWeightsUrl } ) );
  * ```
  *
  * Weights come from the oidn-weights repository, where the "_small" and "_large" variants trade
  * quality against download size and per tile cost.
  */
-export class OIDNDenoiser {
+export class OIDNDenoiser extends EventDispatcher {
 
 	/**
 	 * The denoised result, or null until the first tile has been produced.
@@ -69,6 +81,8 @@ export class OIDNDenoiser {
 	 */
 	constructor( options = {} ) {
 
+		super();
+
 		const {
 			initUNetFromURL,
 			auxWeightsUrl,
@@ -80,7 +94,7 @@ export class OIDNDenoiser {
 
 		if ( ! initUNetFromURL ) {
 
-			throw new Error( 'OIDNDenoiser: "initUNetFromURL" from "oidn-web" must be provided.' );
+			throw new Error( 'OIDNDenoiser: "initUNetFromURL" from "oidn-webgpu" must be provided.' );
 
 		}
 
@@ -88,27 +102,32 @@ export class OIDNDenoiser {
 		this.auxWeightsUrl = auxWeightsUrl;
 		this.colorWeightsUrl = colorWeightsUrl;
 
-		// `false` falls back to the color only model, which is blurrier but skips a scene render
+		// `false` falls back to the color only model, which is blurrier but needs no auxiliary buffers
 		this.useAuxiliaryBuffers = useAuxiliaryBuffers;
 
-		// tiling, passed through to oidn-web. Null keeps its defaults
+		// tiling, passed through to oidn-webgpu. Null keeps its defaults
 		this.maxTileSize = maxTileSize;
 		this.dynamicTile = dynamicTile;
 
 		this.renderer = null;
-		this.scene = null;
-		this.camera = null;
 
 		this._texture = null;
 		this._running = false;
 		this._complete = false;
 		this._abort = null;
 		this._requestId = 0;
+
+		// set when a pass started by "update" fails, so the render loop doesn't start another until a reset
+		this._failed = false;
 		this._unets = { aux: null, color: null };
 
 		this._resultPipeline = null;
 		this._rawTexture = null;
-		this._auxTarget = null;
+
+		// the albedo and normal unpacked from the path tracer's auxiliary target for a pass
+		this._unpackAuxKernel = new UnpackAuxKernel().setWorkgroupSize( 8, 8, 1 );
+		this._albedoTarget = createAuxImageTarget( 'Denoiser Albedo' );
+		this._normalTarget = createAuxImageTarget( 'Denoiser Normal' );
 
 	}
 
@@ -122,41 +141,40 @@ export class OIDNDenoiser {
 	}
 
 	/**
-	 * @param {Scene} scene
-	 * @param {Camera} camera
-	 */
-	setScene( scene, camera ) {
-
-		this.scene = scene;
-		this.camera = camera;
-
-	}
-
-	/**
-	 * Renders the auxiliary buffers and starts a pass. Safe to call every frame.
+	 * Unpacks the auxiliary buffers the path tracer accumulated and starts a pass. Safe to call
+	 * every frame.
 	 *
 	 * @param {Texture} target - The path traced result, in linear HDR.
+	 * @param {StorageArrayTexture|null} aux - The packed auxiliary buffers, see "aux.wgsl.js".
 	 * @returns {Texture|null}
 	 */
-	update( target ) {
+	update( target, aux = null ) {
 
-		if ( this._complete || this._running ) {
+		if ( this._complete || this._running || this._failed ) {
 
 			return this._texture;
 
 		}
 
+		// TODO: denoise the alpha for transparent backgrounds. oidn-webgpu's "denoiseAlpha" runs as a
+		// second pass, but its "_updatePasses" doesn't rebuild its shaders when the option changes
 		let albedo = null;
 		let normal = null;
-		if ( this.useAuxiliaryBuffers ) {
+		if ( this.useAuxiliaryBuffers && aux ) {
 
-			const auxTarget = this._renderAuxiliaryBuffers( target.width, target.height );
-			albedo = auxTarget.textures[ 0 ];
-			normal = auxTarget.textures[ 1 ];
+			this._unpackAux( aux );
+			albedo = this._albedoTarget;
+			normal = this._normalTarget;
 
 		}
 
-		this.denoise( target, albedo, normal );
+		// a failure, such as the weights failing to download, is reported once rather than every frame
+		this.denoise( target, albedo, normal ).catch( error => {
+
+			this._failed = true;
+			this.dispatchEvent( { type: 'error', error } );
+
+		} );
 
 		return this._texture;
 
@@ -213,14 +231,22 @@ export class OIDNDenoiser {
 		const inputs = {
 			color: { data: backend.get( color ).texture, width, height },
 
+			// pace the tiles to display frames so the path tracer keeps rendering between them
+			scheduling: 'animation-frame',
+
 			// the output is seeded with the raw color, so copying per tile shows a progressive wipe
-			progress: output => this._copyOutputToTexture( output, width, height ),
-			done: output => {
+			progress: ( output, tileData, tile, tileIndex, tileCount ) => {
 
 				this._copyOutputToTexture( output, width, height );
+				this.dispatchEvent( { type: 'progress', progress: ( tileIndex + 1 ) / tileCount } );
+
+			},
+			done: output => {
+
 				this._running = false;
 				this._complete = true;
 				this._abort = null;
+				this._disposeAuxImages();
 
 			},
 		};
@@ -254,17 +280,18 @@ export class OIDNDenoiser {
 		this._rawTexture?.destroy();
 		this._rawTexture = null;
 
+		this._disposeAuxImages();
+
 		this._running = false;
 		this._complete = false;
+		this._failed = false;
 
 	}
 
 	dispose() {
 
 		this.reset();
-
-		this._auxTarget?.dispose();
-		this._auxTarget = null;
+		this._unpackAuxKernel.dispose();
 
 		// the networks hold the weights on the GPU, and a load may still be in flight
 		for ( const key in this._unets ) {
@@ -276,52 +303,28 @@ export class OIDNDenoiser {
 
 	}
 
-	// Rasterizes the albedo and normal buffers that guide the filter. oidn-web takes normals
-	// mapped into [0,1], with (0.5, 0.5, 1) as a flat normal.
-	_renderAuxiliaryBuffers( width, height ) {
+	// Unpacks the path tracer's auxiliary target into albedo and normal textures, since oidn-webgpu
+	// reads every input as the same kind as the color texture
+	_unpackAux( aux ) {
 
-		const { renderer, scene, camera } = this;
+		const { renderer, _unpackAuxKernel, _albedoTarget, _normalTarget } = this;
+		const { width, height } = aux.image;
 
-		if ( ! this._auxTarget ) {
+		_albedoTarget.setSize( width, height );
+		_normalTarget.setSize( width, height );
 
-			// Eight bits per channel since both buffers hold [0,1]. Multisampled so the rasterized
-			// silhouettes match the jittered path traced ones.
-			this._auxTarget = new RenderTarget( 1, 1, {
-				count: 2,
-				type: UnsignedByteType,
-				minFilter: NearestFilter,
-				magFilter: NearestFilter,
-				samples: 4,
-			} );
-
-			// the MRT keys are matched against these names
-			this._auxTarget.textures[ 0 ].name = 'output';
-			this._auxTarget.textures[ 1 ].name = 'normal';
-
-		}
+		_unpackAuxKernel.auxTarget = aux;
+		_unpackAuxKernel.albedoTarget = _albedoTarget;
+		_unpackAuxKernel.normalTarget = _normalTarget;
+		renderer.compute( _unpackAuxKernel.kernel, _unpackAuxKernel.getDispatchSize( width, height ) );
 
-		const auxTarget = this._auxTarget;
-		auxTarget.setSize( width, height );
-
-		const originalTarget = renderer.getRenderTarget();
-		const originalMRT = renderer.getMRT();
-		const originalToneMapping = renderer.toneMapping;
-
-		// the buffers are data rather than an image, so they must not be tone mapped
-		renderer.toneMapping = NoToneMapping;
-		renderer.setRenderTarget( auxTarget );
-		renderer.setMRT( mrt( {
-			output: diffuseColor,
-			normal: vec4( normalView.mul( 0.5 ).add( 0.5 ), 1.0 ),
-		} ) );
-
-		renderer.render( scene, camera );
+	}
 
-		renderer.setMRT( originalMRT );
-		renderer.setRenderTarget( originalTarget );
-		renderer.toneMapping = originalToneMapping;
+	// the unpacked images only live for a pass
+	_disposeAuxImages() {
 
-		return auxTarget;
+		this._albedoTarget.dispose();
+		this._normalTarget.dispose();
 
 	}
 
@@ -346,7 +349,7 @@ export class OIDNDenoiser {
 				if ( this.maxTileSize !== null ) options.maxTileSize = this.maxTileSize;
 				if ( this.dynamicTile !== null ) options.dynamicTile = this.dynamicTile;
 
-				return this.initUNetFromURL( url, { device, adapterInfo: device.adapterInfo }, options );
+				return this.initUNetFromURL( url, { device }, options );
 
 			} )();
 
@@ -358,7 +361,7 @@ export class OIDNDenoiser {
 
 	// Copies the denoiser's packed output buffer into a sampleable texture, using a compute pass
 	// since copyBufferToTexture requires 256 byte row alignment.
-	// TODO: remove the copy once oidn-web can write into a caller-provided storage texture.
+	// TODO: remove the copy once oidn-webgpu can write into a caller-provided storage texture.
 	_copyOutputToTexture( output, width, height ) {
 
 		const device = this.renderer.backend.device;

package/src/webgpu/index.d.ts

@@ -1,5 +1,6 @@
-import { Camera, Scene, Texture, ExternalTexture } from 'three';
-import { WebGPURenderer } from 'three/webgpu';
+import { Camera, Color, EventDispatcher, Scene, Texture, ExternalTexture } from 'three';
+import { StorageArrayTexture, WebGPURenderer } from 'three/webgpu';
+import { BVHWorker } from '../index.js';
 
 // three.js type augmentation
 
@@ -12,6 +13,15 @@ declare module 'three' {
 
 	}
 
+	// volume scattering from "KHR_materials_scatter"
+	export interface MeshPhysicalMaterial {
+
+		scatterStrength?: number;
+		multiscatterColor?: Color;
+		scatterAnisotropy?: number;
+
+	}
+
 	export interface Object3D {
 
 		visibleToShadowRays?: boolean;
@@ -102,7 +112,14 @@ export interface OIDNDenoiserOptions {
 
 }
 
-export class OIDNDenoiser {
+export interface OIDNDenoiserEventMap {
+
+	'error': { error: Error };
+	'progress': { progress: number };
+
+}
+
+export class OIDNDenoiser extends EventDispatcher<OIDNDenoiserEventMap> {
 
 	constructor( options: OIDNDenoiserOptions );
 
@@ -118,8 +135,7 @@ export class OIDNDenoiser {
 	readonly running: boolean;
 
 	init( renderer: WebGPURenderer ): void;
-	setScene( scene: Scene, camera: Camera ): void;
-	update( target: Texture ): Texture | null;
+	update( target: Texture, aux?: StorageArrayTexture | null ): Texture | null;
 	denoise( color: Texture, albedo?: Texture | null, normal?: Texture | null ): Promise<void>;
 	reset(): void;
 	dispose(): void;
@@ -155,13 +171,23 @@ export interface DebugBoundsOptions {
 
 }
 
-export class WebGPUPathTracer {
+export interface WebGPUPathTracerEventMap {
+
+	'complete': {};
+	'progress': { stage: 'building' | 'compiling' | 'rendering' | 'denoising', progress: number | null, samples?: SampleCounts };
+
+}
+
+export class WebGPUPathTracer extends EventDispatcher<WebGPUPathTracerEventMap> {
 
 	constructor( renderer: WebGPURenderer );
 
 	maxBounces: number;
 	frameBudget: number;
+	adaptiveFrameBudget: boolean;
+	targetFrameTime: number;
 	maxTransparentBounces: number;
+	maxSubsurfaceBounces: number;
 	maxSamples: number;
 	transmissiveBackground: TransmissiveBackgroundMode;
 	filterGlossyFactor: number;
@@ -174,17 +200,23 @@ export class WebGPUPathTracer {
 	fadeDuration: number;
 	dynamicLowRes: boolean;
 	lowResScale: number;
+	adaptiveDynamicRes: boolean;
 	renderScale: number;
 	synchronizeRenderSize: boolean;
+	renderToCanvas: boolean;
+	asyncCompile: boolean;
 	generateMissingAttributes: boolean;
 	commonAttributes: Array<string>;
 	stableNoise: boolean;
 	pause: boolean;
 
 	readonly target: Texture | null;
+	readonly frameTime: number;
+	readonly complete: boolean;
 	readonly fadeState: number;
 	readonly lowResTarget: Texture;
 	readonly lowResMode: boolean;
+	readonly compiling: boolean;
 	readonly textureAtlas: AtlasTexture;
 
 	getSampleCountsAsync(): Promise<SampleCounts>;
@@ -193,6 +225,8 @@ export class WebGPUPathTracer {
 	setUpscaler( upscaler: FSRUpscaler | null ): void;
 
 	setScene( scene: Scene, camera: Camera ): void;
+	setBVHWorker( WorkerConstructor: new () => BVHWorker & { dispose(): void } ): void;
+	setSceneAsync( scene: Scene, camera: Camera ): Promise<void>;
 	setRandom( random: RandomStrategy ): void;
 	setCamera( camera: Camera ): void;
 	setSize( x: number, y: number ): void;
@@ -208,6 +242,7 @@ export class WebGPUPathTracer {
 	renderDebugBounds( options?: DebugBoundsOptions ): void;
 	renderTextureAtlas( layer?: number ): void;
 	renderSampleDensity(): void;
+	renderAuxBuffer( buffer?: 'albedo' | 'normal' ): void;
 	getRenderTime(): number;
 	dispose(): void;
 

package/src/webgpu/materials/GltfCompliantMaterial.js

@@ -160,8 +160,10 @@ export class GltfCompliantMaterial extends PathtracingMaterial {
 
 						}
 
-						// the refracted half is not attenuated by the layers above
-						result += ( 1.0 - surf.metalness ) * surf.transmission * refraction * surf.color;
+						// the refracted half is not attenuated by the layers above. A volume is entered and exited,
+						// so each crossing takes the square root of the color, as in Cycles
+						let transmissionTint = select( sqrt( surf.color ), surf.color, surf.thinWall );
+						result += ( 1.0 - surf.metalness ) * surf.transmission * refraction * transmissionTint;
 
 					} else {
 
@@ -228,11 +230,15 @@ export class GltfCompliantMaterial extends PathtracingMaterial {
 					let metallic = metallicSpecular * metallicReflectance;
 					let dielectric = dielectricSpecular * dielectricReflectance;
 
-					// the energy the specular interface takes from the layers below
-					let fresnelEnergySS = ${ this.turquinTexture.sampleDielectricFn }( NdotV, surf.roughness, surf.ior ) * dielectricBoost;
+					// The energy the specular interface takes from the layers below, at the lobe's specular color
+					// and intensity. The table holds the albedo at the ior's f0, and the Schlick albedo is linear
+					// in f0, so the tinted albedo slides from it toward the conductor albedo at f0 = 1
+					let iorEnergySS = ${ this.turquinTexture.sampleDielectricFn }( NdotV, surf.roughness, surf.ior );
+					let tintedEnergySS = iorEnergySS + ( dielectricF0 - surf.f0 ) * ( energySS - iorEnergySS ) / ( 1.0 - surf.f0 );
+					let fresnelEnergySS = surf.specularIntensity * tintedEnergySS * dielectricBoost;
 
 					result += attenuation * mix( ( 1.0 - surf.transmission ) * dielectric, metallic, surf.metalness );
-					attenuation *= ( 1.0 - surf.metalness ) * mix( 1.0 - fresnelEnergySS, 1.0 - filmFresnelMax, surf.iridescence );
+					attenuation *= ( 1.0 - surf.metalness ) * mix( 1.0 - fresnelEnergySS, vec3f( 1.0 - filmFresnelMax ), surf.iridescence );
 
 				}
 
@@ -385,6 +391,13 @@ export class GltfCompliantMaterial extends PathtracingMaterial {
 
 						wi = refract( - wo, wh, surf.eta );
 
+						// "refract" returns zero on total internal reflection, so reflect instead and let "isDead" drop it
+						if ( dot( wi, wi ) == 0.0 ) {
+
+							wi = - normalize( reflect( wo, wh ) );
+
+						}
+
 					}
 
 					// the facet choice must agree with the resulting hemisphere - reflection above,
@@ -417,7 +430,8 @@ export class GltfCompliantMaterial extends PathtracingMaterial {
 
 					// Cycles represents a singular event with a large matching BSDF and PDF. Their
 					// ratio preserves throughput while forward MIS correctly gives the event full weight.
-					result.color = ( 1.0 - surf.metalness ) * surf.transmission * surf.color *
+					let transmissionTint = select( sqrt( surf.color ), surf.color, surf.thinWall );
+					result.color = ( 1.0 - surf.metalness ) * surf.transmission * transmissionTint *
 						deltaTransmittance * ${ SINGULAR_EVENT_SCALE };
 					result.direction = worldWi;
 					result.pdf = weights.transmission * deltaProbability * ${ SINGULAR_EVENT_SCALE };

package/src/webgpu/materials/debug/AuxDebugMaterial.js

@@ -0,0 +1,54 @@
+import { MeshBasicNodeMaterial, NoBlending } from 'three/webgpu';
+import { uv, varying, texture, uniform } from 'three/tsl';
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { createAuxTarget } from '../../compute/targets.js';
+import { unpackAuxAlbedoFn, unpackAuxNormalFn, AUX_LAYERS } from '../../nodes/aux.wgsl.js';
+
+// Shows the albedo or normal the path tracer accumulates for the denoiser
+export class AuxDebugMaterial extends MeshBasicNodeMaterial {
+
+	set texture( v ) {
+
+		this._texNode.value = v;
+
+	}
+
+	set showNormal( v ) {
+
+		this._showNormalUniform.value = v ? 1 : 0;
+
+	}
+
+	constructor() {
+
+		super();
+
+		this.blending = NoBlending;
+
+		this._texNode = texture( createAuxTarget() );
+		this._showNormalUniform = uniform( 0, 'uint' );
+
+		const auxDebug = wgslTagFn/* wgsl */`
+			fn auxDebug( tex: texture_2d_array<u32>, coord: vec2f, showNormal: u32 ) -> vec4f {
+
+				// the rows are stored top down, so the quad's bottom up uv is flipped
+				let texel = vec2u( vec2f( coord.x, 1.0 - coord.y ) * vec2f( textureDimensions( tex, 0 ) ) );
+				var packed: vec3u;
+				for ( var layer = 0u; layer < ${ AUX_LAYERS }u; layer ++ ) {
+
+					packed[ layer ] = textureLoad( tex, texel, layer, 0 ).r;
+
+				}
+
+				let albedo = ${ unpackAuxAlbedoFn }( packed );
+				let normal = ${ unpackAuxNormalFn }( packed );
+				return vec4f( select( albedo, normal, showNormal == 1u ), 1.0 );
+
+			}
+		`;
+
+		this.colorNode = auxDebug( this._texNode, varying( uv() ), this._showNormalUniform );
+
+	}
+
+}

package/src/webgpu/nodes/PathtracerBVHComputeData.js

@@ -19,7 +19,8 @@ const transformStruct = new StructTypeNode( {
 	color: 'vec4f',
 }, 'TransformStruct' );
 
-// three-mesh-bvh's ray hit result, plus whether a shadow ray passed a face a bsdf ray would hit
+// three-mesh-bvh's ray hit result. Shadow rays also record the share of bsdf rays the faces they skipped
+// would stop, and the share of light the partially transparent surfaces they passed block
 const intersectionResultStruct = new StructTypeNode( {
 	indices: 'vec4u',
 	normal: 'vec3f',
@@ -28,7 +29,8 @@ const intersectionResultStruct = new StructTypeNode( {
 	objectIndex: 'uint',
 	side: 'float',
 	dist: 'float',
-	forwardBlocked: 'bool',
+	skippedOcclusion: 'float',
+	occlusion: 'float',
 }, 'PathTracerIntersectionResult' );
 
 // Pathtracer-specific version of the BVHComputeData tht includes material mapping, property structs
@@ -179,7 +181,7 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 		const { textureAtlas, storage, fns } = this;
 		const textures = textureAtlas.texture;
-		const textureInfo = uniformArray( textureAtlas.textureInfo, 'uvec4' );
+		const textureInfo = uniformArray( textureAtlas.textureInfo, 'uvec4' ).setName( 'bvh_textureInfo' );
 
 		// build the single sampleTexel bound to this instance's textureInfo node
 		const sampleTexel = sampleTexelFunc( textureInfo, texture( textures ) );
@@ -193,7 +195,8 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 		const scratchRayScalar = float( 1.0 ).toVar( 'bvh_rayScalar' );
 		const baseOpacityScalar = float( 1.0 ).toVar( 'bvh_baseOpacity' );
 
-		// shadow rays hit both sides, and pass through the objects not visible to them
+		// shadow rays hit both sides, pass through the objects not visible to them and partially transparent
+		// surfaces, and stop at the first opaque hit
 		const isShadowRay = bool( false ).toVar( 'bvh_isShadowRay' );
 		const skipShadowObject = bool( false ).toVar( 'bvh_skipShadowObject' );
 
@@ -211,8 +214,8 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 			intersectsBoundsFn: wgslTagFn/* wgsl */`
 				fn rayIntersectsBounds( ray: ${ rayStruct }, bounds: ${ bvhNodeBoundsStruct }, result: ptr<function, ${ intersectionResultStruct }> ) -> u32 {
 
-					// early-out if our object is completely transparent
-					if ( ${ baseOpacityScalar } == 0.0 ) {
+					// early-out if our object is completely transparent, or a shadow ray is already occluded
+					if ( ${ baseOpacityScalar } == 0.0 || ( ${ isShadowRay } && result.didHit ) ) {
 
 						return 0u;
 
@@ -281,10 +284,9 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 							}
 
+							var opacity = ${ baseOpacityScalar };
 							if ( material.transparent != 0 || material.alphaTest > 0.0 ) {
 
-								var opacity = ${ baseOpacityScalar };
-
 								// add support for vertex color opacity
 								if ( material.vertexColors == 1 ) {
 
@@ -341,12 +343,13 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 							}
 
-							// shadow rays pass the objects not visible to them, but a bsdf ray would hit this face
+							// shadow rays skip the objects not visible to them. Record the share of bsdf rays this face
+							// would stop: all of them if it's opaque, its opacity if it's partially transparent
 							if ( ${ skipShadowObject } ) {
 
 								if ( material.side == 0 || triResult.side == material.side ) {
 
-									result.forwardBlocked = true;
+									result.skippedOcclusion += ( 1.0 - result.skippedOcclusion ) * select( 1.0, opacity, material.transparent != 0 );
 
 								}
 
@@ -354,6 +357,15 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 							}
 
+							// shadow rays pass partially transparent surfaces, each blocking its opacity's share of the
+							// light still getting through, just as bsdf rays pass them by chance
+							if ( ${ isShadowRay } && material.transparent != 0 && opacity < 1.0 ) {
+
+								result.occlusion += ( 1.0 - result.occlusion ) * opacity;
+								continue;
+
+							}
+
 							result.didHit = true;
 							result.dist = triResult.dist;
 							result.normal = triResult.normal;
@@ -774,9 +786,8 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 			floatArray[ index ++ ] = getField( m, 'iridescenceIOR', 1.3 );
 
 			// offset 32
-			const iridescenceThicknessRange = getField( m, 'iridescenceThicknessRange', [ 100, 400 ] );
-			floatArray[ index ++ ] = iridescenceThicknessRange[ 0 ];
-			floatArray[ index ++ ] = iridescenceThicknessRange[ 1 ];
+			floatArray[ index ++ ] = getField( m, 'iridescenceThicknessMinimum', 100 );
+			floatArray[ index ++ ] = getField( m, 'iridescenceThicknessMaximum', 400 );
 			floatArray[ index ++ ] = getField( m, 'diffuseRoughness', 0.0 );
 			floatArray[ index ++ ] = getField( m, 'dispersion', 0.0 );
 
@@ -943,6 +954,17 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 			// anisotropyMap transform - offset 264
 			index += writeTextureMatrixToArray( m, 'anisotropyMap', floatArray, index );
 
+			// scattering volume - offset 276
+			const multiscatterColor = getField( m, 'multiscatterColor', null );
+			floatArray[ index ++ ] = multiscatterColor ? multiscatterColor.r : 1.0;
+			floatArray[ index ++ ] = multiscatterColor ? multiscatterColor.g : 1.0;
+			floatArray[ index ++ ] = multiscatterColor ? multiscatterColor.b : 1.0;
+			floatArray[ index ++ ] = getField( m, 'scatterStrength', 0.0 );
+			floatArray[ index ++ ] = getField( m, 'scatterAnisotropy', 0.0 );
+
+			// padding to the struct's 16 byte alignment
+			index += 3;
+
 		}
 
 		return { materialData: intArray, textures };