three-gpu-pathtracer 0.0.11 → 0.0.13

package/build/index.module.js

@@ -1,4 +1,4 @@
-import { ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, NormalBlending, Color, BufferAttribute, Mesh, BufferGeometry, PerspectiveCamera, Camera, SpotLight, RectAreaLight, Spherical, DataTexture, EquirectangularReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, LinearFilter, Vector3, DoubleSide, BackSide, FrontSide, WebGLArrayRenderTarget, UnsignedByteType, MeshBasicMaterial, NoToneMapping, Source, HalfFloatType, DataUtils, RedFormat, Matrix4, Quaternion, Loader, MathUtils, FileLoader, PMREMGenerator, Vector4, DataArrayTexture } from 'three';
+import { ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, Vector4, NormalBlending, Color, Vector3, MathUtils, Matrix4, PerspectiveCamera, BufferAttribute, Mesh, BufferGeometry, Camera, SpotLight, RectAreaLight, Spherical, DataTexture, EquirectangularReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, LinearFilter, DoubleSide, BackSide, FrontSide, WebGLArrayRenderTarget, UnsignedByteType, MeshBasicMaterial, NoToneMapping, Source, HalfFloatType, DataUtils, RedFormat, Quaternion, Loader, FileLoader, PMREMGenerator, DataArrayTexture } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { StaticGeometryGenerator, SAH, MeshBVH, FloatVertexAttributeTexture, MeshBVHUniformStruct, UIntVertexAttributeTexture, shaderStructs, shaderIntersectFunction } from 'three-mesh-bvh';
 import { mergeVertices, mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
@@ -456,6 +456,9 @@ class SobolNumberMapGenerator {
 
 }
 
+const _scissor = new Vector4();
+const _viewport = new Vector4();
+
 function* renderTask() {
 
 	const {
@@ -465,10 +468,13 @@ function* renderTask() {
 		_primaryTarget,
 		_blendTargets,
 		_sobolTarget,
+		_subframe,
 		alpha,
 		camera,
 		material,
 	} = this;
+	const _ogScissor = new Vector4();
+	const _ogViewport = new Vector4();
 
 	const blendMaterial = _blendQuad.material;
 	let [ blendTarget1, blendTarget2 ] = _blendTargets;
@@ -477,20 +483,22 @@ function* renderTask() {
 
 		if ( alpha ) {
 
-			blendMaterial.opacity = 1 / ( this.samples + 1 );
+			blendMaterial.opacity = this._opacityFactor / ( this._samples + 1 );
 			material.blending = NoBlending;
 			material.opacity = 1;
 
 		} else {
 
-			material.opacity = 1 / ( this.samples + 1 );
+			material.opacity = this._opacityFactor / ( this._samples + 1 );
 			material.blending = NormalBlending;
 
 		}
 
+		const [ subX, subY, subW, subH ] = _subframe;
+
 		const w = _primaryTarget.width;
 		const h = _primaryTarget.height;
-		material.resolution.set( w, h );
+		material.resolution.set( w * subW, h * subH );
 		material.sobolTexture = _sobolTarget.texture;
 		material.seed ++;
 
@@ -498,6 +506,7 @@ function* renderTask() {
 		const tilesY = this.tiles.y || 1;
 		const totalTiles = tilesX * tilesY;
 		const dprInv = ( 1 / _renderer.getPixelRatio() );
+
 		for ( let y = 0; y < tilesY; y ++ ) {
 
 			for ( let x = 0; x < tilesX; x ++ ) {
@@ -526,8 +535,12 @@ function* renderTask() {
 
 				material.setDefine( 'CAMERA_TYPE', cameraType );
 
+				// store og state
 				const ogRenderTarget = _renderer.getRenderTarget();
 				const ogAutoClear = _renderer.autoClear;
+				const ogScissorTest = _renderer.getScissorTest();
+				_renderer.getScissor( _ogScissor );
+				_renderer.getViewport( _ogViewport );
 
 				let tx = x;
 				let ty = y;
@@ -544,18 +557,48 @@ function* renderTask() {
 				// three.js renderer takes values relative to the current pixel ratio
 				_renderer.setRenderTarget( _primaryTarget );
 				_renderer.setScissorTest( true );
-				_renderer.setScissor(
-					dprInv * Math.ceil( tx * w / tilesX ),
-					dprInv * Math.ceil( ( tilesY - ty - 1 ) * h / tilesY ),
-					dprInv * Math.ceil( w / tilesX ),
-					dprInv * Math.ceil( h / tilesY ) );
+
+				// set the scissor window for a subtile
+				_scissor.x = tx * w / tilesX;
+				_scissor.y = ( tilesY - ty - 1 ) * h / tilesY;
+				_scissor.z = w / tilesX;
+				_scissor.w = h / tilesY;
+
+				// adjust for the subframe
+				_scissor.x = subX * w + subW * _scissor.x;
+				_scissor.y = subY * h + subH * _scissor.y;
+				_scissor.z = subW * _scissor.z;
+				_scissor.w = subH * _scissor.w;
+
+				// round for floating point cases
+				_scissor.x = _scissor.x;
+				_scissor.y = _scissor.y;
+				_scissor.z = _scissor.z;
+				_scissor.w = _scissor.w;
+
+				// multiply inverse of DPR in because threes multiplies it in
+				_scissor.multiplyScalar( dprInv ).ceil();
+
+				_viewport.x = subX * w;
+				_viewport.y = subY * h;
+				_viewport.z = subW * w;
+				_viewport.w = subH * h;
+				_viewport.multiplyScalar( dprInv ).ceil();
+
+				_renderer.setScissor( _scissor );
+				_renderer.setViewport( _viewport );
+
 				_renderer.autoClear = false;
 				_fsQuad.render( _renderer );
 
-				_renderer.setScissorTest( false );
+				// reset original renderer state
+				_renderer.setViewport( _ogViewport );
+				_renderer.setScissor( _ogScissor );
+				_renderer.setScissorTest( ogScissorTest );
 				_renderer.setRenderTarget( ogRenderTarget );
 				_renderer.autoClear = ogAutoClear;
 
+				// swap and blend alpha targets
 				if ( alpha ) {
 
 					blendMaterial.target1 = blendTarget1.texture;
@@ -567,7 +610,14 @@ function* renderTask() {
 
 				}
 
-				this.samples += ( 1 / totalTiles );
+				this._samples += ( 1 / totalTiles );
+
+				// round the samples value if we've finished the tiles
+				if ( x === tilesX - 1 && y === tilesY - 1 ) {
+
+					this._samples = Math.round( this._samples );
+
+				}
 
 				yield;
 
@@ -577,8 +627,6 @@ function* renderTask() {
 
 		[ blendTarget1, blendTarget2 ] = [ blendTarget2, blendTarget1 ];
 
-		this.samples = Math.round( this.samples );
-
 	}
 
 }
@@ -606,6 +654,12 @@ class PathTracingRenderer {
 
 	set alpha( v ) {
 
+		if ( this._alpha === v ) {
+
+			return;
+
+		}
+
 		if ( ! v ) {
 
 			this._blendTargets[ 0 ].dispose();
@@ -624,15 +678,23 @@ class PathTracingRenderer {
 
 	}
 
+	get samples() {
+
+		return this._samples;
+
+	}
+
 	constructor( renderer ) {
 
 		this.camera = null;
 		this.tiles = new Vector2( 1, 1 );
 
-		this.samples = 0;
 		this.stableNoise = false;
 		this.stableTiles = true;
 
+		this._samples = 0;
+		this._subframe = new Vector4( 0, 0, 1, 1 );
+		this._opacityFactor = 1.0;
 		this._renderer = renderer;
 		this._alpha = false;
 		this._fsQuad = new FullScreenQuad( null );
@@ -660,6 +722,15 @@ class PathTracingRenderer {
 
 	setSize( w, h ) {
 
+		w = Math.ceil( w );
+		h = Math.ceil( h );
+
+		if ( this._primaryTarget.width === w && this._primaryTarget.height === h ) {
+
+			return;
+
+		}
+
 		this._primaryTarget.setSize( w, h );
 		this._blendTargets[ 0 ].setSize( w, h );
 		this._blendTargets[ 1 ].setSize( w, h );
@@ -702,7 +773,7 @@ class PathTracingRenderer {
 		_renderer.setClearColor( ogClearColor, ogClearAlpha );
 		_renderer.setRenderTarget( ogRenderTarget );
 
-		this.samples = 0;
+		this._samples = 0;
 		this._task = null;
 
 		if ( this.stableNoise ) {
@@ -727,6 +798,227 @@ class PathTracingRenderer {
 
 }
 
+function* _task( cb ) {
+
+	const {
+		viewCount,
+		_camera,
+		_quiltUtility,
+		_subframe,
+	} = this;
+
+	const quiltViewInfo = {
+		subframe: _subframe,
+		projectionMatrix: _camera.projectionMatrix,
+		offsetDirection: new Vector3(),
+	};
+
+	while ( true ) {
+
+		for ( let i = 0; i < viewCount; i ++ ) {
+
+			// get the camera info for the current view index
+			_quiltUtility.near = this.camera.near;
+			_quiltUtility.far = this.camera.far;
+			_quiltUtility.getCameraViewInfo( i, quiltViewInfo );
+
+			// transform offset into world frame from camera frame
+			quiltViewInfo.offsetDirection.transformDirection( this.camera.matrixWorld );
+
+			// adjust the render camera with the view offset
+			this.camera.matrixWorld.decompose(
+				_camera.position,
+				_camera.quaternion,
+				_camera.scale,
+			);
+			_camera.position.addScaledVector( quiltViewInfo.offsetDirection, quiltViewInfo.offset );
+			_camera.updateMatrixWorld();
+
+			// get the inverse projection
+			_camera.projectionMatrixInverse
+				.copy( _camera.projectionMatrix )
+				.invert();
+
+			this._opacityFactor = Math.floor( this._samples + 1 ) / Math.floor( this._quiltSamples + 1 );
+
+			do {
+
+				const ogCamera = this.camera;
+				this.camera = _camera;
+				cb();
+				this.camera = ogCamera;
+				yield;
+
+			} while ( this._samples % 1 !== 0 );
+
+			this._quiltSamples += 1 / viewCount;
+
+		}
+
+		this._quiltSamples = Math.round( this._quiltSamples );
+
+	}
+
+}
+
+// Helper for extracting the camera projection, offset, and quilt subframe needed
+// for rendering a quilt with the provided parameters.
+class QuiltViewUtility {
+
+	constructor() {
+
+		this.viewCount = 48;
+		this.quiltDimensions = new Vector2( 8, 6 );
+		this.viewCone = 35 * MathUtils.DEG2RAD;
+		this.viewFoV = 14 * MathUtils.DEG2RAD;
+		this.displayDistance = 1;
+		this.displayAspect = 0.75;
+		this.near = 0.01;
+		this.far = 10;
+
+	}
+
+	getCameraViewInfo( i, target = {} ) {
+
+		const {
+			quiltDimensions,
+			viewCone,
+			displayDistance,
+			viewCount,
+			viewFoV,
+			displayAspect,
+			near,
+			far,
+		} = this;
+
+		// initialize defaults
+		target.subframe = target.subframe || new Vector4();
+		target.offsetDirection = target.offsetDirection || new Vector3();
+		target.projectionMatrix	= target.projectionMatrix || new Matrix4();
+
+		// set camera offset
+		const halfWidth = Math.tan( 0.5 * viewCone ) * displayDistance;
+		const totalWidth = halfWidth * 2.0;
+		const stride = totalWidth / ( viewCount - 1 );
+		const offset = viewCount === 1 ? 0 : - halfWidth + stride * i;
+		target.offsetDirection.set( 1.0, 0, 0 );
+		target.offset = offset;
+
+		// set the projection matrix
+		const displayHalfHeight = Math.tan( viewFoV * 0.5 ) * displayDistance;
+		const displayHalfWidth = displayAspect * displayHalfHeight;
+		const nearScale = near / displayDistance;
+
+		target.projectionMatrix.makePerspective(
+			nearScale * ( - displayHalfWidth - offset ), nearScale * ( displayHalfWidth - offset ),
+			nearScale * displayHalfHeight, nearScale * - displayHalfHeight,
+			near, far,
+		);
+
+		// set the quilt subframe
+		const x = i % quiltDimensions.x;
+		const y = Math.floor( i / quiltDimensions.x );
+
+		const qw = 1 / quiltDimensions.x;
+		const qh = 1 / quiltDimensions.y;
+		target.subframe.set( x * qw, y * qh, qw, qh );
+
+		return target;
+
+	}
+
+	setFromDisplayView( viewerDistance, displayWidth, displayHeight ) {
+
+		this.displayAspect = displayWidth / displayHeight;
+		this.displayDistance = viewerDistance;
+		this.viewFoV = 2.0 * Math.atan( 0.5 * displayHeight / viewerDistance );
+
+	}
+
+}
+
+class QuiltPathTracingRenderer extends PathTracingRenderer {
+
+	get samples() {
+
+		return this._samples / this.viewCount;
+
+	}
+
+	constructor( ...args ) {
+
+		super( ...args );
+
+		[
+			'quiltDimensions',
+			'viewCount',
+			'viewCone',
+			'viewFoV',
+			'displayDistance',
+			'displayAspect',
+		].forEach( member => {
+
+			Object.defineProperty( this, member, {
+
+				enumerable: true,
+
+				set: v => {
+
+					this._quiltUtility[ member ] = v;
+
+				},
+
+				get: () => {
+
+					return this._quiltUtility[ member ];
+
+				}
+
+			} );
+
+		} );
+
+
+		this._quiltUtility = new QuiltViewUtility();
+		this._quiltSamples = 0;
+		this._camera = new PerspectiveCamera();
+		this._quiltTask = null;
+
+	}
+
+	setFromDisplayView( ...args ) {
+
+		this._quiltUtility.setFromDisplayView( ...args );
+
+	}
+
+	update() {
+
+		this.alpha = false;
+		if ( ! this._quiltTask ) {
+
+			this._quiltTask = _task.call( this, () => {
+
+				super.update();
+
+			} );
+
+		}
+
+		this._quiltTask.next();
+
+	}
+
+	reset() {
+
+		super.reset();
+		this._quiltTask = null;
+		this._quiltSamples = 0;
+
+	}
+
+}
+
 function getGroupMaterialIndicesAttribute( geometry, materials, allMaterials ) {
 
 	const indexAttr = geometry.index;
@@ -971,7 +1263,7 @@ class PathTracingSceneGenerator {
 
 					meshes.push( c );
 
-				} else if ( c.isRectAreaLight || c.isSpotLight ) {
+				} else if ( c.isRectAreaLight || c.isSpotLight || c.isDirectionalLight || c.isPointLight ) {
 
 					lights.push( c );
 
@@ -1825,7 +2117,7 @@ class MaterialsTexture extends DataTexture {
 			}
 
 			index ++;
-			index ++;
+			floatArray[ index ++ ] = getField( m, 'sheen', 0.0 );
 
 			// sample 7
 			// sheen
@@ -2170,31 +2462,45 @@ class EquirectHdrInfoUniform {
 
 	constructor() {
 
+		// Default to a white texture and associated weights so we don't
+		// just render black initially.
+		const whiteTex = new DataTexture( new Float32Array( [ 1, 1, 1, 1 ] ), 1, 1 );
+		whiteTex.type = FloatType;
+		whiteTex.format = RGBAFormat;
+		whiteTex.minFilter = LinearFilter;
+		whiteTex.magFilter = LinearFilter;
+		whiteTex.wrapS = RepeatWrapping;
+		whiteTex.wrapT = RepeatWrapping;
+		whiteTex.generateMipmaps = false;
+		whiteTex.needsUpdate = true;
+
 		// Stores a map of [0, 1] value -> cumulative importance row & pdf
 		// used to sampling a random value to a relevant row to sample from
-		const marginalWeights = new DataTexture();
+		const marginalWeights = new DataTexture( new Float32Array( [ 0, 1 ] ), 1, 2 );
 		marginalWeights.type = FloatType;
 		marginalWeights.format = RedFormat;
 		marginalWeights.minFilter = LinearFilter;
 		marginalWeights.magFilter = LinearFilter;
 		marginalWeights.generateMipmaps = false;
+		marginalWeights.needsUpdate = true;
 
 		// Stores a map of [0, 1] value -> cumulative importance column & pdf
 		// used to sampling a random value to a relevant pixel to sample from
-		const conditionalWeights = new DataTexture();
+		const conditionalWeights = new DataTexture( new Float32Array( [ 0, 0, 1, 1 ] ), 2, 2 );
 		conditionalWeights.type = FloatType;
 		conditionalWeights.format = RedFormat;
 		conditionalWeights.minFilter = LinearFilter;
 		conditionalWeights.magFilter = LinearFilter;
 		conditionalWeights.generateMipmaps = false;
+		conditionalWeights.needsUpdate = true;
 
+		this.map = whiteTex;
 		this.marginalWeights = marginalWeights;
 		this.conditionalWeights = conditionalWeights;
-		this.map = null;
 
 		// the total sum value is separated into two values to work around low precision
 		// storage of floating values in structs
-		this.totalSumWhole = 0;
+		this.totalSumWhole = 1;
 		this.totalSumDecimal = 0;
 
 	}
@@ -2203,7 +2509,7 @@ class EquirectHdrInfoUniform {
 
 		this.marginalWeights.dispose();
 		this.conditionalWeights.dispose();
-		if ( this.map ) this.map.dispose();
+		this.map.dispose();
 
 	}
 
@@ -2542,7 +2848,10 @@ class LightsInfoUniformStruct {
 
 			} else if ( l.isPointLight ) {
 
-				const worldPosition = l.getWorldPosition( u );
+				const worldPosition = u.setFromMatrixPosition( l.matrixWorld );
+
+				// sample 3
+				// u vector
 				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.x;
 				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.y;
 				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.z;
@@ -2559,10 +2868,12 @@ class LightsInfoUniformStruct {
 
 			} else if ( l.isDirectionalLight ) {
 
-				const worldPosition = l.getWorldPosition( u );
-				const targetPosition = l.target.getWorldPosition( v );
-
+				const worldPosition = u.setFromMatrixPosition( l.matrixWorld );
+				const targetPosition = v.setFromMatrixPosition( l.target.matrixWorld );
 				target.subVectors( worldPosition, targetPosition ).normalize();
+
+				// sample 3
+				// u vector
 				floatArray[ baseIndex + ( index ++ ) ] = target.x;
 				floatArray[ baseIndex + ( index ++ ) ] = target.y;
 				floatArray[ baseIndex + ( index ++ ) ] = target.z;
@@ -2984,6 +3295,22 @@ class IESProfilesTexture extends WebGLArrayRenderTarget {
 
 const shaderUtils = /* glsl */`
 
+	#ifndef RAY_OFFSET
+	#define RAY_OFFSET 1e-4
+	#endif
+
+	// adjust the hit point by the surface normal by a factor of some offset and the
+	// maximum component-wise value of the current point to accommodate floating point
+	// error as values increase.
+	vec3 stepRayOrigin( vec3 rayOrigin, vec3 rayDirection, vec3 offset, float dist ) {
+
+		vec3 point = rayOrigin + rayDirection * dist;
+		vec3 absPoint = abs( point );
+		float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
+		return point + offset * ( maxPoint + 1.0 ) * RAY_OFFSET;
+
+	}
+
 	// https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_volume/README.md#attenuation
 	vec3 transmissionAttenuation( float dist, vec3 attColor, float attDist ) {
 
@@ -3915,6 +4242,7 @@ const shaderMaterialStructs = /* glsl */ `
 		float side;
 		bool matte;
 
+		float sheen;
 		vec3 sheenColor;
 		int sheenColorMap;
 		float sheenRoughness;
@@ -4004,6 +4332,7 @@ const shaderMaterialStructs = /* glsl */ `
 		m.clearcoatNormalMap = int( round( s5.a ) );
 		m.clearcoatNormalScale = s6.rg;
 
+		m.sheen = s6.a;
 		m.sheenColor = s7.rgb;
 		m.sheenColorMap = int( round( s7.a ) );
 		m.sheenRoughness = s8.r;
@@ -4443,6 +4772,7 @@ vec3 evalIridescence( float outsideIOR, float eta2, float cosTheta1, float thinF
 		phi12 = PI;
 
 	}
+
 	float phi21 = PI - phi12;
 
 	// Second interface
@@ -4455,11 +4785,13 @@ vec3 evalIridescence( float outsideIOR, float eta2, float cosTheta1, float thinF
 		phi23[ 0 ] = PI;
 
 	}
+
 	if ( baseIOR[1] < iridescenceIor ) {
 
 		phi23[ 1 ] = PI;
 
 	}
+
 	if ( baseIOR[2] < iridescenceIor ) {
 
 		phi23[ 2 ] = PI;
@@ -4481,15 +4813,17 @@ vec3 evalIridescence( float outsideIOR, float eta2, float cosTheta1, float thinF
 
 	// Reflectance term for m > 0 (pairs of diracs)
 	vec3 Cm = Rs - T121;
-	for ( int m = 1; m <= 2; ++ m )
-	{
+	for ( int m = 1; m <= 2; ++ m ) {
+
 		Cm *= r123;
 		vec3 Sm = 2.0 * evalSensitivity( float( m ) * OPD, float( m ) * phi );
 		I += Cm * Sm;
+
 	}
 
 	// Since out of gamut colors might be produced, negative color values are clamped to 0.
 	return max( I, vec3( 0.0 ) );
+
 }
 
 `;
@@ -4523,6 +4857,7 @@ struct SurfaceRec {
 	float clearcoat;
 	float clearcoatRoughness;
 	float filteredClearcoatRoughness;
+	float sheen;
 	vec3 sheenColor;
 	float sheenRoughness;
 	float iridescence;
@@ -4598,12 +4933,12 @@ float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRec surf, out vec3 color )
 
 	// if roughness is set to 0 then D === NaN which results in black pixels
 	float metalness = surf.metalness;
-	float filteredRoughness = surf.filteredRoughness;
+	float roughness = surf.filteredRoughness;
 
 	float eta = surf.eta;
 	float f0 = surf.f0;
-	float G = ggxShadowMaskG2( wi, wo, filteredRoughness );
-	float D = ggxDistribution( wh, filteredRoughness );
+	float G = ggxShadowMaskG2( wi, wo, roughness );
+	float D = ggxDistribution( wh, roughness );
 	float FM = disneyFresnel( surf, wo, wi, wh );
 	float cosTheta = min( wo.z, 1.0 );
 	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
@@ -4614,20 +4949,23 @@ float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRec surf, out vec3 color )
 
 	}
 
-	vec3 metalColor = surf.color;
-	vec3 dielectricColor = f0 * surf.specularColor;
-	vec3 specColor = mix( dielectricColor, metalColor, surf.metalness );
+	vec3 baseColor = mix( f0 * surf.specularColor * surf.specularIntensity, surf.color, surf.metalness );
+	vec3 iridescenceFresnel = evalIridescence( 1.0, surf.iridescenceIor, dot( wi, wh ), surf.iridescenceThickness, baseColor );
 
-	vec3 iridescenceF = evalIridescence( 1.0, surf.iridescenceIor, dot( wi, wh ), surf.iridescenceThickness, vec3( f0 ) );
-	vec3 iridescenceMix = mix( vec3( FM ), iridescenceF, surf.iridescence );
-	vec3 F = mix( specColor, vec3( 1.0 ), iridescenceMix );
+	vec3 metalMix = mix( surf.color, iridescenceFresnel, surf.iridescence );
+	vec3 metalFresnel = mix( metalMix, vec3( 1.0 ), FM );
 
-	color = mix( surf.specularIntensity, 1.0, surf.metalness ) * wi.z * F * G * D / ( 4.0 * abs( wi.z * wo.z ) );
+	vec3 dielectricIriMix = mix( iridescenceFresnel, vec3( 1.0 ), FM );
+	vec3 dielectricMix = mix( f0 * surf.specularColor, vec3( 1.0 ), FM ) * surf.specularIntensity;
+	vec3 dielectricFresnel = mix( dielectricMix, dielectricIriMix, surf.iridescence );
+
+	vec3 F = mix( dielectricFresnel, metalFresnel, surf.metalness );
+	color = wi.z * F * G * D / ( 4.0 * abs( wi.z * wo.z ) );
 
 	// PDF
 	// See 14.1.1 Microfacet BxDFs in https://www.pbr-book.org/
 	float incidentTheta = acos( wo.z );
-	float G1 = ggxShadowMaskG1( incidentTheta, filteredRoughness );
+	float G1 = ggxShadowMaskG1( incidentTheta, roughness );
 	float ggxPdf = D * G1 * max( 0.0, abs( dot( wo, wh ) ) ) / abs ( wo.z );
 	return ggxPdf / ( 4.0 * dot( wo, wh ) );
 
@@ -4636,10 +4974,10 @@ float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRec surf, out vec3 color )
 vec3 specularDirection( vec3 wo, SurfaceRec surf ) {
 
 	// sample ggx vndf distribution which gives a new normal
-	float filteredRoughness = surf.filteredRoughness;
+	float roughness = surf.filteredRoughness;
 	vec3 halfVector = ggxDirection(
 		wo,
-		vec2( filteredRoughness ),
+		vec2( roughness ),
 		sobol2( 12 )
 	);
 
@@ -4716,7 +5054,7 @@ float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRec surf, out vec3 col
 
 vec3 transmissionDirection( vec3 wo, SurfaceRec surf ) {
 
-	float roughness = surf.roughness;
+	float roughness = surf.filteredRoughness;
 	float eta = surf.eta;
 	vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( sobol2( 13 ) ) * roughness );
 	vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
@@ -4736,11 +5074,11 @@ float clearcoatEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRec surf, inout vec3 colo
 	float ior = 1.5;
 	float f0 = iorRatioToF0( ior );
 	bool frontFace = surf.frontFace;
-	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+	float roughness = surf.filteredClearcoatRoughness;
 
 	float eta = frontFace ? 1.0 / ior : ior;
-	float G = ggxShadowMaskG2( wi, wo, filteredClearcoatRoughness );
-	float D = ggxDistribution( wh, filteredClearcoatRoughness );
+	float G = ggxShadowMaskG2( wi, wo, roughness );
+	float D = ggxDistribution( wh, roughness );
 	float F = schlickFresnel( dot( wi, wh ), f0 );
 	float cosTheta = min( wo.z, 1.0 );
 	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
@@ -4756,17 +5094,17 @@ float clearcoatEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRec surf, inout vec3 colo
 
 	// PDF
 	// See equation (27) in http://jcgt.org/published/0003/02/03/
-	return ggxPDF( wo, wh, filteredClearcoatRoughness ) / ( 4.0 * dot( wi, wh ) );
+	return ggxPDF( wo, wh, roughness ) / ( 4.0 * dot( wi, wh ) );
 
 }
 
 vec3 clearcoatDirection( vec3 wo, SurfaceRec surf ) {
 
 	// sample ggx vndf distribution which gives a new normal
-	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+	float roughness = surf.filteredClearcoatRoughness;
 	vec3 halfVector = ggxDirection(
 		wo,
-		vec2( filteredClearcoatRoughness ),
+		vec2( roughness ),
 		sobol2( 14 )
 	);
 
@@ -4795,11 +5133,10 @@ vec3 sheenColor( vec3 wo, vec3 wi, vec3 wh, SurfaceRec surf ) {
 }
 
 // bsdf
-#define DIFF_WEIGHT 0
-#define SPEC_WEIGHT 1
-#define TRANS_WEIGHT 2
-#define CC_WEIGHT 3
-void getLobeWeights( vec3 wo, vec3 wi, vec3 wh, vec3 clearcoatWo, SurfaceRec surf, out float[ 4 ] weights ) {
+void getLobeWeights(
+	vec3 wo, vec3 wi, vec3 wh, vec3 clearcoatWo, SurfaceRec surf,
+	out float diffuseWeight, out float specularWeight, out float transmissionWeight, out float clearcoatWeight
+) {
 
 	float metalness = surf.metalness;
 	float transmission = surf.transmission;
@@ -4821,25 +5158,22 @@ void getLobeWeights( vec3 wo, vec3 wi, vec3 wh, vec3 clearcoatWo, SurfaceRec sur
 	float transSpecularProb = mix( max( 0.25, reflectance ), 1.0, metalness );
 	float diffSpecularProb = 0.5 + 0.5 * metalness;
 
-	float diffuseWeight = ( 1.0 - transmission ) * ( 1.0 - diffSpecularProb );
-	float specularWeight = transmission * transSpecularProb + ( 1.0 - transmission ) * diffSpecularProb;
-	float transmissionWeight = transmission * ( 1.0 - transSpecularProb );
-	float clearcoatWeight = surf.clearcoat * schlickFresnel( clearcoatWo.z, 0.04 );
+	diffuseWeight = ( 1.0 - transmission ) * ( 1.0 - diffSpecularProb );
+	specularWeight = transmission * transSpecularProb + ( 1.0 - transmission ) * diffSpecularProb;
+	transmissionWeight = transmission * ( 1.0 - transSpecularProb );
+	clearcoatWeight = surf.clearcoat * schlickFresnel( clearcoatWo.z, 0.04 );
 
 	float totalWeight = diffuseWeight + specularWeight + transmissionWeight + clearcoatWeight;
-	weights[ DIFF_WEIGHT ] = diffuseWeight / totalWeight;
-	weights[ SPEC_WEIGHT ] = specularWeight / totalWeight;
-	weights[ TRANS_WEIGHT ] = transmissionWeight / totalWeight;
-	weights[ CC_WEIGHT ] = clearcoatWeight / totalWeight;
-
+	diffuseWeight /= totalWeight;
+	specularWeight /= totalWeight;
+	transmissionWeight /= totalWeight;
+	clearcoatWeight /= totalWeight;
 }
 
-float bsdfEval( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, float[ 4 ] weights, out float specularPdf, out vec3 color ) {
-
-	float diffuseWeight = weights[ DIFF_WEIGHT ];
-	float specularWeight = weights[ SPEC_WEIGHT ];
-	float transmissionWeight = weights[ TRANS_WEIGHT ];
-	float clearcoatWeight = weights[ CC_WEIGHT ];
+float bsdfEval(
+	vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf,
+	float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight, out float specularPdf, out vec3 color
+) {
 
 	float metalness = surf.metalness;
 	float transmission = surf.transmission;
@@ -4889,8 +5223,8 @@ float bsdfEval( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec
 	}
 
 	// sheen
-	color *= sheenAlbedoScaling( wo, wi, surf );
-	color += sheenColor( wo, wi, halfVector, surf );
+	color *= mix( 1.0, sheenAlbedoScaling( wo, wi, surf ), surf.sheen );
+	color += sheenColor( wo, wi, halfVector, surf ) * surf.sheen;
 
 	// clearcoat
 	if ( clearcoatWi.z >= 0.0 && clearcoatWeight > 0.0 ) {
@@ -4915,20 +5249,32 @@ float bsdfEval( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec
 
 float bsdfResult( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, out vec3 color ) {
 
-	float[ 4 ] pdf;
 	vec3 wh = getHalfVector( wo, wi, surf.eta );
-	getLobeWeights( wo, wi, wh, clearcoatWo, surf, pdf );
+	float diffuseWeight;
+	float specularWeight;
+	float transmissionWeight;
+	float clearcoatWeight;
+	getLobeWeights( wo, wi, wh, clearcoatWo, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
 
 	float specularPdf;
-	return bsdfEval( wo, clearcoatWo, wi, clearcoatWi, surf, pdf, specularPdf, color );
+	return bsdfEval( wo, clearcoatWo, wi, clearcoatWi, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight, specularPdf, color );
 
 }
 
 SampleRec bsdfSample( vec3 wo, vec3 clearcoatWo, mat3 normalBasis, mat3 invBasis, mat3 clearcoatNormalBasis, mat3 clearcoatInvBasis, SurfaceRec surf ) {
 
+	float diffuseWeight;
+	float specularWeight;
+	float transmissionWeight;
+	float clearcoatWeight;
 	// using normal and basically-reflected ray since we don't have proper half vector here
+	getLobeWeights( wo, wo, vec3( 0, 0, 1 ), clearcoatWo, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+
 	float pdf[4];
-	getLobeWeights( wo, wo, vec3( 0, 0, 1 ), clearcoatWo, surf, pdf );
+	pdf[0] = diffuseWeight;
+	pdf[1] = specularWeight;
+	pdf[2] = transmissionWeight;
+	pdf[3] = clearcoatWeight;
 
 	float cdf[4];
 	cdf[0] = pdf[0];
@@ -4980,7 +5326,7 @@ SampleRec bsdfSample( vec3 wo, vec3 clearcoatWo, mat3 normalBasis, mat3 invBasis
 	}
 
 	SampleRec result;
-	result.pdf = bsdfEval( wo, clearcoatWo, wi, clearcoatWi, surf, pdf, result.specularPdf, result.color );
+	result.pdf = bsdfEval( wo, clearcoatWo, wi, clearcoatWi, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight, result.specularPdf, result.color );
 	result.direction = wi;
 	result.clearcoatDirection = clearcoatWi;
 
@@ -5580,9 +5926,9 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 			defines: {
 				FEATURE_MIS: 1,
+				FEATURE_RUSSIAN_ROULETTE: 1,
 				FEATURE_DOF: 1,
 				FEATURE_BACKGROUND_MAP: 0,
-				TRANSPARENT_TRAVERSALS: 5,
 				// 0 = Perspective
 				// 1 = Orthographic
 				// 2 = Equirectangular
@@ -5597,7 +5943,8 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 			uniforms: {
 				resolution: { value: new Vector2() },
 
-				bounces: { value: 3 },
+				bounces: { value: 10 },
+				transmissiveBounces: { value: 10 },
 				physicalCamera: { value: new PhysicalCameraUniform() },
 
 				bvh: { value: new MeshBVHUniformStruct() },
@@ -5640,6 +5987,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 			fragmentShader: /* glsl */`
 				#define RAY_OFFSET 1e-4
+				#define INFINITY 1e20
 
 				precision highp isampler2D;
 				precision highp usampler2D;
@@ -5678,6 +6026,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 				uniform vec2 resolution;
 				uniform int bounces;
+				uniform int transmissiveBounces;
 				uniform mat4 cameraWorldMatrix;
 				uniform mat4 invProjectionMatrix;
 				uniform sampler2DArray attributesArray;
@@ -5727,7 +6076,10 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				}
 
 				// step through multiple surface hits and accumulate color attenuation based on transmissive surfaces
-				bool attenuateHit( BVH bvh, vec3 rayOrigin, vec3 rayDirection, int traversals, bool isShadowRay, out vec3 color ) {
+				bool attenuateHit(
+					BVH bvh, vec3 rayOrigin, vec3 rayDirection, float rayDist,
+					int traversals, int transparentTraversals, bool isShadowRay, out vec3 color
+				) {
 
 					// hit results
 					uvec4 faceIndices = uvec4( 0u );
@@ -5744,6 +6096,12 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 						if ( bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist ) ) {
 
+							if ( dist > rayDist ) {
+
+								return true;
+
+							}
+
 							// TODO: attenuate the contribution based on the PDF of the resulting ray including refraction values
 							// Should be able to work using the material BSDF functions which will take into account specularity, etc.
 							// TODO: should we account for emissive surfaces here?
@@ -5755,11 +6113,8 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 							Material material = readMaterialInfo( materials, materialIndex );
 
 							// adjust the ray to the new surface
-							bool isBelowSurface = dot( rayDirection, faceNormal ) < 0.0;
-							vec3 point = rayOrigin + rayDirection * dist;
-							vec3 absPoint = abs( point );
-							float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
-							rayOrigin = point + faceNormal * ( maxPoint + 1.0 ) * ( isBelowSurface ? - RAY_OFFSET : RAY_OFFSET );
+							bool isEntering = side == 1.0;
+							rayOrigin = stepRayOrigin( rayOrigin, rayDirection, - faceNormal, dist );
 
 							if ( ! material.castShadow && isShadowRay ) {
 
@@ -5829,7 +6184,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 							}
 
-							if ( side == 1.0 && isBelowSurface ) {
+							if ( side == 1.0 && isEntering ) {
 
 								// only attenuate by surface color on the way in
 								color *= mix( vec3( 1.0 ), albedo.rgb, transmissionFactor );
@@ -5841,6 +6196,15 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 							}
 
+							bool isTransmissiveRay = dot( rayDirection, faceNormal * side ) < 0.0;
+							if ( ( isTransmissiveRay || isEntering ) && transparentTraversals > 0 ) {
+
+								transparentTraversals --;
+								i --;
+
+							}
+
+
 						} else {
 
 							return false;
@@ -5853,19 +6217,6 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 				}
 
-				// returns whether the ray hit anything before a certain distance, not just the first surface. Could be optimized to not check the full hierarchy.
-				bool anyCloserHit( BVH bvh, vec3 rayOrigin, vec3 rayDirection, float maxDist ) {
-
-					uvec4 faceIndices = uvec4( 0u );
-					vec3 faceNormal = vec3( 0.0, 0.0, 1.0 );
-					vec3 barycoord = vec3( 0.0 );
-					float side = 1.0;
-					float dist = 0.0;
-					bool hit = bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist );
-					return hit && dist < maxDist;
-
-				}
-
 				vec3 ndcToRayOrigin( vec2 coord ) {
 
 					vec4 rayOrigin4 = cameraWorldMatrix * invProjectionMatrix * vec4( coord, - 1.0, 1.0 );
@@ -5974,7 +6325,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 					float accumulatedRoughness = 0.0;
 					float accumulatedClearcoatRoughness = 0.0;
 					bool transmissiveRay = true;
-					int transparentTraversals = TRANSPARENT_TRAVERSALS;
+					int transparentTraversals = transmissiveBounces;
 					vec3 throughputColor = vec3( 1.0 );
 					SampleRec sampleRec;
 					int i;
@@ -5985,12 +6336,12 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						sobolBounceIndex ++;
 
 						bool hit = bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist );
-
+						bool firstRay = i == 0 && transparentTraversals == transmissiveBounces;
 						LightSampleRec lightHit = lightsClosestHit( lights.tex, lights.count, rayOrigin, rayDirection );
 
-						if ( lightHit.hit && ( lightHit.dist < dist || !hit ) ) {
+						if ( lightHit.hit && ( lightHit.dist < dist || ! hit ) ) {
 
-							if ( i == 0 || transmissiveRay ) {
+							if ( firstRay || transmissiveRay ) {
 
 								gl_FragColor.rgb += lightHit.emission * throughputColor;
 
@@ -6024,7 +6375,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 						if ( ! hit ) {
 
-							if ( i == 0 || transmissiveRay ) {
+							if ( firstRay || transmissiveRay ) {
 
 								gl_FragColor.rgb += sampleBackground( envRotation3x3 * rayDirection, sobol2( 2 ) ) * throughputColor;
 								gl_FragColor.a = backgroundAlpha;
@@ -6059,7 +6410,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						uint materialIndex = uTexelFetch1D( materialIndexAttribute, faceIndices.x ).r;
 						Material material = readMaterialInfo( materials, materialIndex );
 
-						if ( material.matte && i == 0 ) {
+						if ( material.matte && firstRay ) {
 
 							gl_FragColor = vec4( 0.0 );
 							break;
@@ -6070,11 +6421,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						// then skip it
 						if ( ! material.castShadow && isShadowRay ) {
 
-							vec3 point = rayOrigin + rayDirection * dist;
-							vec3 absPoint = abs( point );
-							float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
-							rayOrigin = point - ( maxPoint + 1.0 ) * faceNormal * RAY_OFFSET;
-
+							rayOrigin = stepRayOrigin( rayOrigin, rayDirection, - faceNormal, dist );
 							continue;
 
 						}
@@ -6123,10 +6470,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 							|| material.transparent && ! useAlphaTest && albedo.a < sobol( 3 )
 						) {
 
-							vec3 point = rayOrigin + rayDirection * dist;
-							vec3 absPoint = abs( point );
-							float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
-							rayOrigin = point - ( maxPoint + 1.0 ) * faceNormal * RAY_OFFSET;
+							rayOrigin = stepRayOrigin( rayOrigin, rayDirection, - faceNormal, dist );
 
 							// only allow a limited number of transparency discards otherwise we could
 							// crash the context with too long a loop.
@@ -6333,6 +6677,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						surfaceRec.metalness = metalness;
 						surfaceRec.color = albedo.rgb;
 						surfaceRec.clearcoat = clearcoat;
+						surfaceRec.sheen = material.sheen;
 						surfaceRec.sheenColor = sheenColor;
 						surfaceRec.iridescence = iridescence;
 						surfaceRec.iridescenceIor = material.iridescenceIor;
@@ -6342,11 +6687,12 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						surfaceRec.attenuationColor = material.attenuationColor;
 						surfaceRec.attenuationDistance = material.attenuationDistance;
 
-						// apply perceptual roughness factor from gltf
+						// apply perceptual roughness factor from gltf. sheen perceptual roughness is
+						// applied by its brdf function
 						// https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#microfacet-surfaces
 						surfaceRec.roughness = roughness * roughness;
 						surfaceRec.clearcoatRoughness = clearcoatRoughness * clearcoatRoughness;
-						surfaceRec.sheenRoughness = sheenRoughness * sheenRoughness;
+						surfaceRec.sheenRoughness = sheenRoughness;
 
 						// frontFace is used to determine transmissive properties and PDF. If no transmission is used
 						// then we can just always assume this is a front face.
@@ -6372,18 +6718,14 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						vec3 clearcoatOutgoing = - normalize( clearcoatInvBasis * rayDirection );
 						sampleRec = bsdfSample( outgoing, clearcoatOutgoing, normalBasis, invBasis, clearcoatNormalBasis, clearcoatInvBasis, surfaceRec );
 
+						bool wasBelowSurface = dot( rayDirection, faceNormal ) > 0.0;
 						isShadowRay = sampleRec.specularPdf < sobol( 4 );
 
-						// adjust the hit point by the surface normal by a factor of some offset and the
-						// maximum component-wise value of the current point to accommodate floating point
-						// error as values increase.
-						vec3 point = rayOrigin + rayDirection * dist;
-						vec3 absPoint = abs( point );
-						float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
+						vec3 prevRayDirection = rayDirection;
 						rayDirection = normalize( normalBasis * sampleRec.direction );
 
 						bool isBelowSurface = dot( rayDirection, faceNormal ) < 0.0;
-						rayOrigin = point + faceNormal * ( maxPoint + 1.0 ) * ( isBelowSurface ? - RAY_OFFSET : RAY_OFFSET );
+						rayOrigin = stepRayOrigin( rayOrigin, prevRayDirection, isBelowSurface ? - faceNormal : faceNormal, dist );
 
 						// direct env map sampling
 						#if FEATURE_MIS
@@ -6402,10 +6744,11 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 							}
 
 							// check if a ray could even reach the light area
+							vec3 attenuatedColor;
 							if (
 								lightSampleRec.pdf > 0.0 &&
 								isDirectionValid( lightSampleRec.direction, normal, faceNormal ) &&
-								! anyCloserHit( bvh, rayOrigin, lightSampleRec.direction, lightSampleRec.dist )
+								! attenuateHit( bvh, rayOrigin, lightSampleRec.direction, lightSampleRec.dist, bounces - i, transparentTraversals, isShadowRay, attenuatedColor )
 							) {
 
 								// get the material pdf
@@ -6417,7 +6760,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 									// weight the direct light contribution
 									float lightPdf = lightSampleRec.pdf / float( lights.count + 1u );
 									float misWeight = lightSampleRec.type == SPOT_LIGHT_TYPE || lightSampleRec.type == DIR_LIGHT_TYPE || lightSampleRec.type == POINT_LIGHT_TYPE ? 1.0 : misHeuristic( lightPdf, lightMaterialPdf );
-									gl_FragColor.rgb += lightSampleRec.emission * throughputColor * sampleColor * misWeight / lightPdf;
+									gl_FragColor.rgb += attenuatedColor * lightSampleRec.emission * throughputColor * sampleColor * misWeight / lightPdf;
 
 								}
 
@@ -6445,7 +6788,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 							if (
 								envPdf > 0.0 &&
 								isDirectionValid( envDirection, normal, faceNormal ) &&
-								! attenuateHit( bvh, rayOrigin, envDirection, bounces - i, isShadowRay, attenuatedColor )
+								! attenuateHit( bvh, rayOrigin, envDirection, INFINITY, bounces - i, transparentTraversals, isShadowRay, attenuatedColor )
 							) {
 
 								// get the material pdf
@@ -6481,6 +6824,16 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 						}
 
+						// if we're bouncing around the inside a transmissive material then decrement
+						// perform this separate from a bounce
+						bool isTransmissiveRay = dot( rayDirection, faceNormal * side ) < 0.0;
+						if ( ( isTransmissiveRay || isBelowSurface ) && transparentTraversals > 0 ) {
+
+							transparentTraversals --;
+							i --;
+
+						}
+
 						// accumulate color
 						gl_FragColor.rgb += ( emission * throughputColor );
 
@@ -6491,6 +6844,29 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 						}
 
+						#if FEATURE_RUSSIAN_ROULETTE
+
+						// russian roulette path termination
+						// https://www.arnoldrenderer.com/research/physically_based_shader_design_in_arnold.pdf
+						uint minBounces = 3u;
+						float depthProb = float( sobolBounceIndex < minBounces );
+
+						float rrProb = luminance( throughputColor * sampleRec.color / sampleRec.pdf );
+						rrProb /= luminance( throughputColor );
+						rrProb = sqrt( rrProb );
+						rrProb = max( rrProb, depthProb );
+						rrProb = min( rrProb, 1.0 );
+						if ( sobol( 8 ) > rrProb ) {
+
+							break;
+
+						}
+
+						// perform sample clamping here to avoid bright pixels
+						throughputColor *= min( 1.0 / rrProb, 20.0 );
+
+						#endif
+
 						throughputColor *= sampleRec.color / sampleRec.pdf;
 
 						// attenuate the throughput color by the medium color
@@ -6507,6 +6883,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 						}
 
+
 					}
 
 					gl_FragColor.a *= opacity;
@@ -6525,5 +6902,5 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 // core
 
-export { BlurredEnvMapGenerator, DenoiseMaterial, DynamicPathTracingSceneGenerator, EquirectCamera, EquirectHdrInfoUniform, GradientEquirectTexture, GraphMaterial, IESLoader, IESProfilesTexture, LightsInfoUniformStruct, MaterialBase, MaterialReducer, MaterialsTexture, PathTracingRenderer, PathTracingSceneGenerator, PhysicalCamera, PhysicalCameraUniform, PhysicalPathTracingMaterial, PhysicalSpotLight, ProceduralEquirectTexture, RenderTarget2DArray, ShapedAreaLight, getGroupMaterialIndicesAttribute, mergeMeshes, setCommonAttributes, shaderLightStruct, shaderMaterialSampling, shaderMaterialStructs, shaderUtils, trimToAttributes };
+export { BlurredEnvMapGenerator, DenoiseMaterial, DynamicPathTracingSceneGenerator, EquirectCamera, EquirectHdrInfoUniform, GradientEquirectTexture, GraphMaterial, IESLoader, IESProfilesTexture, LightsInfoUniformStruct, MaterialBase, MaterialReducer, MaterialsTexture, PathTracingRenderer, PathTracingSceneGenerator, PhysicalCamera, PhysicalCameraUniform, PhysicalPathTracingMaterial, PhysicalSpotLight, ProceduralEquirectTexture, QuiltPathTracingRenderer, RenderTarget2DArray, ShapedAreaLight, getGroupMaterialIndicesAttribute, mergeMeshes, setCommonAttributes, shaderLightStruct, shaderMaterialSampling, shaderMaterialStructs, shaderUtils, trimToAttributes };
 //# sourceMappingURL=index.module.js.map