three-gpu-pathtracer 0.0.17 → 0.0.19

package/build/index.umd.cjs

@@ -457,9 +457,6 @@
 
 	}
 
-	const _scissor = new three.Vector4();
-	const _viewport = new three.Vector4();
-
 	function* renderTask() {
 
 		const {
@@ -501,12 +498,21 @@
 			const h = _primaryTarget.height;
 			material.resolution.set( w * subW, h * subH );
 			material.sobolTexture = _sobolTarget.texture;
+			material.stratifiedTexture.init( 20, material.bounces + material.transmissiveBounces + 5 );
+			material.stratifiedTexture.next();
 			material.seed ++;
 
 			const tilesX = this.tiles.x || 1;
 			const tilesY = this.tiles.y || 1;
 			const totalTiles = tilesX * tilesY;
-			const dprInv = ( 1 / _renderer.getPixelRatio() );
+
+			const pxSubW = Math.ceil( w * subW );
+			const pxSubH = Math.ceil( h * subH );
+			const pxSubX = Math.floor( subX * w );
+			const pxSubY = Math.floor( subY * h );
+
+			const pxTileW = Math.ceil( pxSubW / tilesX );
+			const pxTileH = Math.ceil( pxSubH / tilesY );
 
 			for ( let y = 0; y < tilesY; y ++ ) {
 
@@ -555,40 +561,28 @@
 
 					}
 
+					// set the scissor and the viewport on the render target
+					// note that when using the webgl renderer set viewport the device pixel ratio
+					// is multiplied into the field causing some pixels to not be rendered
+					const reverseTy = tilesY - ty - 1;
+					_primaryTarget.scissor.set(
+						pxSubX + tx * pxTileW,
+						pxSubY + reverseTy * pxTileH,
+						Math.min( pxTileW, pxSubW - tx * pxTileW ),
+						Math.min( pxTileH, pxSubH - reverseTy * pxTileH ),
+					);
+
+					_primaryTarget.viewport.set(
+						pxSubX,
+						pxSubY,
+						pxSubW,
+						pxSubH,
+					);
+
 					// three.js renderer takes values relative to the current pixel ratio
 					_renderer.setRenderTarget( _primaryTarget );
 					_renderer.setScissorTest( true );
 
-					// 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 );
 
@@ -1078,25 +1072,6 @@
 
 	}
 
-	function trimToAttributes( geometry, attributes ) {
-
-		// trim any unneeded attributes
-		if ( attributes ) {
-
-			for ( const key in geometry.attributes ) {
-
-				if ( ! attributes.includes( key ) ) {
-
-					geometry.deleteAttribute( key );
-
-				}
-
-			}
-
-		}
-
-	}
-
 	function setCommonAttributes( geometry, options ) {
 
 		const { attributes = [], normalMapRequired = false } = options;
@@ -1114,6 +1089,13 @@
 
 		}
 
+		if ( ! geometry.attributes.uv2 && ( attributes && attributes.includes( 'uv2' ) ) ) {
+
+			const vertCount = geometry.attributes.position.count;
+			geometry.setAttribute( 'uv2', new three.BufferAttribute( new Float32Array( vertCount * 2 ), 2, false ) );
+
+		}
+
 		if ( ! geometry.attributes.tangent && ( attributes && attributes.includes( 'tangent' ) ) ) {
 
 			if ( normalMapRequired ) {
@@ -1162,169 +1144,46 @@
 
 	}
 
-	function mergeMeshes( meshes, options = {} ) {
-
-		options = { attributes: null, cloneGeometry: true, ...options };
+	const dummyMaterial = new three.MeshBasicMaterial();
+	function getDummyMesh() {
 
-		const transformedGeometry = [];
-		const materialSet = new Set();
-		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+		const emptyGeometry = new three.BufferGeometry();
+		emptyGeometry.setAttribute( 'position', new three.BufferAttribute( new Float32Array( 9 ), 3 ) );
+		return new three.Mesh( emptyGeometry, dummyMaterial );
 
-			// save any materials
-			const mesh = meshes[ i ];
-			if ( mesh.visible === false ) continue;
-
-			if ( Array.isArray( mesh.material ) ) {
-
-				mesh.material.forEach( m => materialSet.add( m ) );
-
-			} else {
-
-				materialSet.add( mesh.material );
-
-			}
-
-		}
-
-		const materials = Array.from( materialSet );
-		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
-
-			// ensure the matrix world is up to date
-			const mesh = meshes[ i ];
-			if ( mesh.visible === false ) continue;
-
-			mesh.updateMatrixWorld();
-
-			// apply the matrix world to the geometry
-			const originalGeometry = meshes[ i ].geometry;
-			const geometry = options.cloneGeometry ? originalGeometry.clone() : originalGeometry;
-			geometry.applyMatrix4( mesh.matrixWorld );
-
-			if ( mesh.matrixWorld.determinant() < 0 ) {
-
-				geometry.index.array.reverse();
-
-			}
+	}
 
-			// ensure our geometry has common attributes
-			setCommonAttributes( geometry, {
-				attributes: options.attributes,
-				normalMapRequired: ! ! mesh.material.normalMap,
-			} );
-			trimToAttributes( geometry, options.attributes );
+	class DynamicPathTracingSceneGenerator {
 
-			// create the material index attribute
-			const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, mesh.material, materials );
-			geometry.setAttribute( 'materialIndex', materialIndexAttribute );
+		get initialized() {
 
-			transformedGeometry.push( geometry );
+			return Boolean( this.bvh );
 
 		}
 
-		const textureSet = new Set();
-		materials.forEach( material => {
-
-			for ( const key in material ) {
+		constructor( objects ) {
 
-				const value = material[ key ];
-				if ( value && value.isTexture ) {
+			// ensure the objects is an array
+			if ( ! Array.isArray( objects ) ) {
 
-					textureSet.add( value );
-
-				}
+				objects = [ objects ];
 
 			}
 
-		} );
-
-		const geometry = BufferGeometryUtils_js.mergeGeometries( transformedGeometry, false );
-		const textures = Array.from( textureSet );
-		return { geometry, materials, textures };
-
-	}
-
-	class PathTracingSceneGenerator {
-
-		prepScene( scene ) {
+			// use a dummy object for a fallback
+			const finalObjects = [ ...objects ];
+			if ( finalObjects.length === 0 ) {
 
-			scene = Array.isArray( scene ) ? scene : [ scene ];
-
-			const meshes = [];
-			const lights = [];
-
-			for ( let i = 0, l = scene.length; i < l; i ++ ) {
-
-				scene[ i ].traverseVisible( c => {
-
-					if ( c.isSkinnedMesh || c.isMesh && c.morphTargetInfluences ) {
-
-						const generator = new threeMeshBvh.StaticGeometryGenerator( c );
-						generator.attributes = [ 'position', 'color', 'normal', 'tangent', 'uv', 'uv2' ];
-						generator.applyWorldTransforms = false;
-						const mesh = new three.Mesh(
-							generator.generate(),
-							c.material,
-						);
-						mesh.matrixWorld.copy( c.matrixWorld );
-						mesh.matrix.copy( c.matrixWorld );
-						mesh.matrix.decompose( mesh.position, mesh.quaternion, mesh.scale );
-						meshes.push( mesh );
-
-					} else if ( c.isMesh ) {
-
-						meshes.push( c );
-
-					} else if (
-						c.isRectAreaLight ||
-						c.isSpotLight ||
-						c.isPointLight ||
-						c.isDirectionalLight
-					) {
-
-						lights.push( c );
-
-					}
-
-				} );
+				finalObjects.push( getDummyMesh() );
 
 			}
 
-			return {
-				...mergeMeshes( meshes, {
-					attributes: [ 'position', 'normal', 'tangent', 'uv', 'color' ],
-				} ),
-				lights,
-			};
-
-		}
-
-		generate( scene, options = {} ) {
-
-			const { materials, textures, geometry, lights } = this.prepScene( scene );
-			const bvhOptions = { strategy: threeMeshBvh.SAH, ...options, maxLeafTris: 1 };
-			return {
-				scene,
-				materials,
-				textures,
-				lights,
-				bvh: new threeMeshBvh.MeshBVH( geometry, bvhOptions ),
-			};
-
-		}
-
-	}
-
-	class DynamicPathTracingSceneGenerator {
-
-		get initialized() {
-
-			return Boolean( this.bvh );
-
-		}
-
-		constructor( scene ) {
+			// options
+			this.bvhOptions = {};
+			this.attributes = [ 'position', 'normal', 'tangent', 'color', 'uv', 'uv2' ];
 
-			this.objects = Array.isArray( scene ) ? scene : [ scene ];
+			// state
+			this.objects = finalObjects;
 			this.bvh = null;
 			this.geometry = new three.BufferGeometry();
 			this.materials = null;
@@ -1348,64 +1207,75 @@
 
 		dispose() {}
 
-		generate() {
+		prepScene() {
 
-			const { objects, staticGeometryGenerator, geometry, lights } = this;
-			if ( this.bvh === null ) {
+			if ( this.bvh !== null ) {
 
-				const attributes = [ 'position', 'normal', 'tangent', 'uv', 'color' ];
+				return;
 
-				for ( let i = 0, l = objects.length; i < l; i ++ ) {
+			}
 
-					objects[ i ].traverse( c => {
+			const { objects, staticGeometryGenerator, geometry, lights, attributes } = this;
+			for ( let i = 0, l = objects.length; i < l; i ++ ) {
 
-						if ( c.isMesh ) {
+				objects[ i ].traverse( c => {
 
-							const normalMapRequired = ! ! c.material.normalMap;
-							setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
+					if ( c.isMesh ) {
 
-						} else if (
-							c.isRectAreaLight ||
-							c.isSpotLight ||
-							c.isPointLight ||
-							c.isDirectionalLight
-						) {
+						const normalMapRequired = ! ! c.material.normalMap;
+						setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
 
-							lights.push( c );
+					} else if (
+						c.isRectAreaLight ||
+						c.isSpotLight ||
+						c.isPointLight ||
+						c.isDirectionalLight
+					) {
 
-						}
+						lights.push( c );
 
-					} );
+					}
 
-				}
+				} );
 
-				const textureSet = new Set();
-				const materials = staticGeometryGenerator.getMaterials();
-				materials.forEach( material => {
+			}
 
-					for ( const key in material ) {
+			const textureSet = new Set();
+			const materials = staticGeometryGenerator.getMaterials();
+			materials.forEach( material => {
 
-						const value = material[ key ];
-						if ( value && value.isTexture ) {
+				for ( const key in material ) {
 
-							textureSet.add( value );
+					const value = material[ key ];
+					if ( value && value.isTexture ) {
 
-						}
+						textureSet.add( value );
 
 					}
 
-				} );
+				}
 
-				staticGeometryGenerator.attributes = attributes;
-				staticGeometryGenerator.generate( geometry );
+			} );
+
+			staticGeometryGenerator.attributes = attributes;
+			staticGeometryGenerator.generate( geometry );
+
+			const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, materials, materials );
+			geometry.setAttribute( 'materialIndex', materialIndexAttribute );
+			geometry.clearGroups();
+
+			this.materials = materials;
+			this.textures = Array.from( textureSet );
+
+		}
 
-				const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, materials, materials );
-				geometry.setAttribute( 'materialIndex', materialIndexAttribute );
-				geometry.clearGroups();
+		generate() {
+
+			const { objects, staticGeometryGenerator, geometry, bvhOptions } = this;
+			if ( this.bvh === null ) {
 
-				this.bvh = new threeMeshBvh.MeshBVH( geometry );
-				this.materials = materials;
-				this.textures = Array.from( textureSet );
+				this.prepScene();
+				this.bvh = new threeMeshBvh.MeshBVH( geometry, { strategy: threeMeshBvh.SAH, maxLeafTris: 1, ...bvhOptions } );
 
 				return {
 					lights: this.lights,
@@ -1435,6 +1305,30 @@
 
 	}
 
+	class PathTracingSceneGenerator {
+
+		generate( scene, options = {} ) {
+
+			// ensure scene transforms are up to date
+			// TODO: remove this?
+			if ( Array.isArray( scene ) ) {
+
+				scene.forEach( s => s.updateMatrixWorld( true ) );
+
+			} else {
+
+				scene.updateMatrixWorld( true );
+
+			}
+
+			const generator = new DynamicPathTracingSceneGenerator( scene );
+			generator.bvhOptions = options;
+			return generator.generate();
+
+		}
+
+	}
+
 	// https://github.com/gkjohnson/webxr-sandbox/blob/main/skinned-mesh-batching/src/MaterialReducer.js
 
 	function isTypedArray( arr ) {
@@ -1799,8 +1693,8 @@
 		constructor( width = 512, height = 512 ) {
 
 			super(
-				new Uint16Array( width * height * 4 ),
-				width, height, three.RGBAFormat, three.HalfFloatType, three.EquirectangularReflectionMapping,
+				new Float32Array( width * height * 4 ),
+				width, height, three.RGBAFormat, three.FloatType, three.EquirectangularReflectionMapping,
 				three.RepeatWrapping, three.ClampToEdgeWrapping, three.LinearFilter, three.LinearFilter,
 			);
 
@@ -1832,10 +1726,10 @@
 
 					const i = y * width + x;
 					const i4 = 4 * i;
-					data[ i4 + 0 ] = three.DataUtils.toHalfFloat( _color.r );
-					data[ i4 + 1 ] = three.DataUtils.toHalfFloat( _color.g );
-					data[ i4 + 2 ] = three.DataUtils.toHalfFloat( _color.b );
-					data[ i4 + 3 ] = three.DataUtils.toHalfFloat( 1.0 );
+					data[ i4 + 0 ] = ( _color.r );
+					data[ i4 + 1 ] = ( _color.g );
+					data[ i4 + 2 ] = ( _color.b );
+					data[ i4 + 3 ] = ( 1.0 );
 
 				}
 
@@ -1890,7 +1784,7 @@
 	// when rendering each texture to the texture array they must have a consistent color space.
 	function getTextureHash( t ) {
 
-		return `${ t.source.uuid }:${ t.encoding }`;
+		return `${ t.source.uuid }:${ t.colorSpace }`;
 
 	}
 
@@ -2102,7 +1996,7 @@
 
 			let index = 0;
 			const pixelCount = materials.length * MATERIAL_PIXELS;
-			const dimension = Math.ceil( Math.sqrt( pixelCount ) );
+			const dimension = Math.ceil( Math.sqrt( pixelCount ) ) || 1;
 			const { threeCompatibilityTransforms, image, features } = this;
 
 			// get the list of textures with unique sources
@@ -2440,7 +2334,7 @@
 
 			};
 
-			const fsQuad = new Pass_js.FullScreenQuad( new three.MeshBasicMaterial() );
+			const fsQuad = new Pass_js.FullScreenQuad( new CopyMaterial() );
 			this.fsQuad = fsQuad;
 
 		}
@@ -2475,7 +2369,6 @@
 					texture.matrix.identity();
 
 					fsQuad.material.map = texture;
-					fsQuad.material.transparent = true;
 
 					renderer.setRenderTarget( this, i );
 					fsQuad.render( renderer );
@@ -2505,6 +2398,54 @@
 
 	}
 
+	class CopyMaterial extends three.ShaderMaterial {
+
+		get map() {
+
+			return this.uniforms.map.value;
+
+		}
+		set map( v ) {
+
+			this.uniforms.map.value = v;
+
+		}
+
+		constructor() {
+
+			super( {
+				uniforms: {
+
+					map: { value: null },
+
+				},
+
+				vertexShader: /* glsl */`
+				varying vec2 vUv;
+				void main() {
+
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}
+			`,
+
+				fragmentShader: /* glsl */`
+				uniform sampler2D map;
+				varying vec2 vUv;
+				void main() {
+
+					gl_FragColor = texture2D( map, vUv );
+
+				}
+			`
+			} );
+
+		}
+
+
+	}
+
 	function toHalfFloatArray( f32Array ) {
 
 		const f16Array = new Uint16Array( f32Array.length );
@@ -2556,7 +2497,7 @@
 	}
 
 	// ensures the data is all floating point values and flipY is false
-	function preprocessEnvMap( envMap ) {
+	function preprocessEnvMap( envMap, targetType = three.HalfFloatType ) {
 
 		const map = envMap.clone();
 		map.source = new three.Source( { ...map.image } );
@@ -2565,17 +2506,54 @@
 		// TODO: is there a simple way to avoid cloning and adjusting the env map data here?
 		// convert the data from half float uint 16 arrays to float arrays for cdf computation
 		let newData = data;
-		if ( map.type === three.HalfFloatType ) {
+		if ( map.type !== targetType ) {
+
+			if ( targetType === three.HalfFloatType ) {
+
+				newData = new Uint16Array( data.length );
+
+			} else {
+
+				newData = new Float32Array( data.length );
+
+			}
+
+			let maxIntValue;
+			if ( data instanceof Int8Array || data instanceof Int16Array || data instanceof Int32Array ) {
+
+				maxIntValue = 2 ** ( 8 * data.BYTES_PER_ELEMENT - 1 ) - 1;
+
+			} else {
+
+				maxIntValue = 2 ** ( 8 * data.BYTES_PER_ELEMENT ) - 1;
+
+			}
+
+			for ( let i = 0, l = data.length; i < l; i ++ ) {
+
+				let v = data[ i ];
+				if ( map.type === three.HalfFloatType ) {
+
+					v = three.DataUtils.fromHalfFloat( data[ i ] );
+
+				}
+
+				if ( map.type !== three.FloatType && map.type !== three.HalfFloatType ) {
+
+					v /= maxIntValue;
+
+				}
+
+				if ( targetType === three.HalfFloatType ) {
 
-			newData = new Uint16Array( data.length );
-			for ( const i in data ) {
+					newData[ i ] = three.DataUtils.toHalfFloat( v );
 
-				newData[ i ] = data[ i ];
+				}
 
 			}
 
 			map.image.data = newData;
-			map.type = three.HalfFloatType;
+			map.type = targetType;
 
 		}
 
@@ -2667,7 +2645,7 @@
 			// https://pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Sampling_Light_Sources#InfiniteAreaLights
 			const map = preprocessEnvMap( hdr );
 			map.wrapS = three.RepeatWrapping;
-			map.wrapT = three.RepeatWrapping;
+			map.wrapT = three.ClampToEdgeWrapping;
 
 			const { width, height, data } = map.image;
 
@@ -2879,6 +2857,13 @@
 				const baseIndex = i * LIGHT_PIXELS * 4;
 				let index = 0;
 
+				// initialize to 0
+				for ( let p = 0; p < LIGHT_PIXELS * 4; p ++ ) {
+
+					floatArray[ baseIndex + p ] = 0;
+
+				}
+
 				// sample 1
 			    // position
 				l.getWorldPosition( v );
@@ -2943,7 +2928,7 @@
 
 				} else if ( l.isSpotLight ) {
 
-					const radius = l.radius;
+					const radius = l.radius || 0;
 					eye.setFromMatrixPosition( l.matrixWorld );
 					target.setFromMatrixPosition( l.target.matrixWorld );
 					m.lookAt( eye, target, up );
@@ -2973,24 +2958,21 @@
 					// radius
 					floatArray[ baseIndex + ( index ++ ) ] = radius;
 
-					// near
-					floatArray[ baseIndex + ( index ++ ) ] = l.shadow.camera.near;
-
 					// decay
 					floatArray[ baseIndex + ( index ++ ) ] = l.decay;
 
 					// distance
 					floatArray[ baseIndex + ( index ++ ) ] = l.distance;
 
-					// sample 6
 					// coneCos
 					floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle );
 
+					// sample 6
 					// penumbraCos
 					floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle * ( 1 - l.penumbra ) );
 
 					// iesProfile
-					floatArray[ baseIndex + ( index ++ ) ] = iesTextures.indexOf( l.iesTexture );
+					floatArray[ baseIndex + ( index ++ ) ] = l.iesTexture ? iesTextures.indexOf( l.iesTexture ) : - 1;
 
 				} else if ( l.isPointLight ) {
 
@@ -3007,7 +2989,7 @@
 					index += 4;
 
 					// sample 5
-					index += 2;
+					index += 1;
 
 					floatArray[ baseIndex + ( index ++ ) ] = l.decay;
 					floatArray[ baseIndex + ( index ++ ) ] = l.distance;
@@ -4421,18 +4403,16 @@
 			vec4 s4 = texelFetch1D( tex, i + 4u );
 			vec4 s5 = texelFetch1D( tex, i + 5u );
 			l.radius = s4.r;
-			l.near = s4.g;
-			l.decay = s4.b;
-			l.distance = s4.a;
+			l.decay = s4.g;
+			l.distance = s4.b;
+			l.coneCos = s4.a;
 
-			l.coneCos = s5.r;
-			l.penumbraCos = s5.g;
-			l.iesProfile = int( round( s5.b ) );
+			l.penumbraCos = s5.r;
+			l.iesProfile = int( round( s5.g ) );
 
 		} else {
 
 			l.radius = 0.0;
-			l.near = 0.0;
 			l.decay = 0.0;
 			l.distance = 0.0;
 
@@ -5150,15 +5130,17 @@ bool bvhIntersectFogVolumeHit(
 
 		// TODO: subsurface approx?
 
-		float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float F = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 		color = ( 1.0 - F ) * transFactor * metalFactor * wi.z * surf.color * ( retro + lambert ) / PI;
+
 		return wi.z / PI;
 
 	}
 
 	vec3 diffuseDirection( vec3 wo, SurfaceRecord surf ) {
 
-		vec3 lightDirection = sampleSphere( sobol2( 11 ) );
+		vec3 lightDirection = sampleSphere( rand2( 11 ) );
 		lightDirection.z += 1.0;
 		lightDirection = normalize( lightDirection );
 
@@ -5203,7 +5185,7 @@ bool bvhIntersectFogVolumeHit(
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
-			sobol2( 12 )
+			rand2( 12 )
 		);
 
 		// apply to new ray by reflecting off the new normal
@@ -5240,7 +5222,7 @@ bool bvhIntersectFogVolumeHit(
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( filteredRoughness ),
-			sobol2( 13 )
+			rand2( 13 )
 		);
 
 		vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
@@ -5262,7 +5244,8 @@ bool bvhIntersectFogVolumeHit(
 		color = surf.transmission * surf.color;
 
 		// PDF
-		float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float F = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 		if ( F >= 1.0 ) {
 
 			return 0.0;
@@ -5277,7 +5260,7 @@ bool bvhIntersectFogVolumeHit(
 
 		float roughness = surf.filteredRoughness;
 		float eta = surf.eta;
-		vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( sobol2( 13 ) ) * roughness );
+		vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( rand2( 13 ) ) * roughness );
 		vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
 
 		if ( surf.thinFilm ) {
@@ -5318,7 +5301,7 @@ bool bvhIntersectFogVolumeHit(
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
-			sobol2( 14 )
+			rand2( 14 )
 		);
 
 		// apply to new ray by reflecting off the new normal
@@ -5353,7 +5336,8 @@ bool bvhIntersectFogVolumeHit(
 
 		float metalness = surf.metalness;
 		float transmission = surf.transmission;
-		float fEstimate = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float fEstimate = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float fEstimate = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 
 		float transSpecularProb = mix( max( 0.25, fEstimate ), 1.0, metalness );
 		float diffSpecularProb = 0.5 + 0.5 * metalness;
@@ -5469,7 +5453,7 @@ bool bvhIntersectFogVolumeHit(
 			ScatterRecord sampleRec;
 			sampleRec.specularPdf = 0.0;
 			sampleRec.pdf = 1.0 / ( 4.0 * PI );
-			sampleRec.direction = sampleSphere( sobol2( 16 ) );
+			sampleRec.direction = sampleSphere( rand2( 16 ) );
 			sampleRec.color = surf.color / ( 4.0 * PI );
 			return sampleRec;
 
@@ -5521,7 +5505,7 @@ bool bvhIntersectFogVolumeHit(
 		vec3 wi;
 		vec3 clearcoatWi;
 
-		float r = sobol( 15 );
+		float r = rand( 15 );
 		if ( r <= cdf[0] ) { // diffuse
 
 			wi = diffuseDirection( wo, surf );
@@ -5605,10 +5589,17 @@ bool bvhIntersectFogVolumeHit(
 	// samples the color given env map with CDF and returns the pdf of the direction
 	float sampleEquirect( vec3 direction, inout vec3 color ) {
 
+		float totalSum = envMapInfo.totalSum;
+		if ( totalSum == 0.0 ) {
+
+			color = vec3( 0.0 );
+			return 1.0;
+
+		}
+
 		vec2 uv = equirectDirectionToUv( direction );
 		color = texture2D( envMapInfo.map, uv ).rgb;
 
-		float totalSum = envMapInfo.totalSum;
 		float lum = luminance( color );
 		ivec2 resolution = textureSize( envMapInfo.map, 0 );
 		float pdf = lum / totalSum;
@@ -6160,32 +6151,38 @@ bool bvhIntersectFogVolumeHit(
 
 	}
 
-	float evaluateFresnelWeight( float cosTheta, float eta, float f0 ) {
+	// TODO: disney fresnel was removed and replaced with this fresnel function to better align with
+	// the glTF but is causing blown out pixels. Should be revisited
+	// float evaluateFresnelWeight( float cosTheta, float eta, float f0 ) {
 
-		if ( totalInternalReflection( cosTheta, eta ) ) {
+	// 	if ( totalInternalReflection( cosTheta, eta ) ) {
 
-			return 1.0;
+	// 		return 1.0;
 
-		}
+	// 	}
 
-		return schlickFresnel( cosTheta, f0 );
+	// 	return schlickFresnel( cosTheta, f0 );
 
-	}
+	// }
 
-	/*
 	// https://schuttejoe.github.io/post/disneybsdf/
 	float disneyFresnel( vec3 wo, vec3 wi, vec3 wh, float f0, float eta, float metalness ) {
 
 		float dotHV = dot( wo, wh );
-		float dotHL = dot( wi, wh );
+		if ( totalInternalReflection( dotHV, eta ) ) {
+
+			return 1.0;
 
+		}
+
+		float dotHL = dot( wi, wh );
 		float dielectricFresnel = dielectricFresnel( abs( dotHV ), eta );
 		float metallicFresnel = schlickFresnel( dotHL, f0 );
 
 		return mix( dielectricFresnel, metallicFresnel, metalness );
 
 	}
-	*/
+
 `;
 
 	const arraySamplerTexelFetchGLSL = /*glsl */`
@@ -6242,28 +6239,28 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 	// returns [ 0, 1 ]
-	float rand() {
+	float pcgRand() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return float( WHITE_NOISE_SEED.x ) / float( 0xffffffffu );
 
 	}
 
-	vec2 rand2() {
+	vec2 pcgRand2() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec2( WHITE_NOISE_SEED.xy ) / float(0xffffffffu);
 
 	}
 
-	vec3 rand3() {
+	vec3 pcgRand3() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec3( WHITE_NOISE_SEED.xyz ) / float( 0xffffffffu );
 
 	}
 
-	vec4 rand4() {
+	vec4 pcgRand4() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec4( WHITE_NOISE_SEED ) / float( 0xffffffffu );
@@ -6336,7 +6333,7 @@ bool bvhIntersectFogVolumeHit(
 
 		// Jitter the camera ray by finding a uv coordinate at a random sample
 		// around this pixel's UV coordinate for AA
-		vec2 ruv = sobol2( 0 );
+		vec2 ruv = rand2( 0 );
 		vec2 jitteredUv = vUv + vec2( tentFilter( ruv.x ) * ssd.x, tentFilter( ruv.y ) * ssd.y );
 		Ray ray;
 
@@ -6381,7 +6378,7 @@ bool bvhIntersectFogVolumeHit(
 
 			// get the aperture sample
 			// if blades === 0 then we assume a circle
-			vec3 shapeUVW= sobol3( 1 );
+			vec3 shapeUVW= rand3( 1 );
 			int blades = physicalCamera.apertureBlades;
 			float anamorphicRatio = physicalCamera.anamorphicRatio;
 			vec2 apertureSample = blades == 0 ? sampleCircle( shapeUVW.xy ) : sampleRegularPolygon( blades, shapeUVW );
@@ -6417,6 +6414,9 @@ bool bvhIntersectFogVolumeHit(
 		out vec3 color
 	) {
 
+		// store the original bounce index so we can reset it after
+		uint originalBounceIndex = sobolBounceIndex;
+
 		int traversals = state.traversals;
 		int transmissiveTraversals = state.transmissiveTraversals;
 		bool isShadowRay = state.isShadowRay;
@@ -6429,22 +6429,25 @@ bool bvhIntersectFogVolumeHit(
 
 		color = vec3( 1.0 );
 
-		// TODO: we should be using sobol sampling here instead of rand but the sobol bounce and path indices need to be incremented
-		// and then reset.
+		bool result = true;
 		for ( int i = 0; i < traversals; i ++ ) {
 
+			sobolBounceIndex ++;
+
 			int hitType = traceScene( ray, fogMaterial, surfaceHit );
 
 			if ( hitType == FOG_HIT ) {
 
-				return true;
+				result = true;
+				break;
 
 			} else if ( hitType == SURFACE_HIT ) {
 
 				float totalDist = distance( startPoint, ray.origin + ray.direction * surfaceHit.dist );
 				if ( totalDist > rayDist ) {
 
-					return false;
+					result = false;
+					break;
 
 				}
 
@@ -6526,7 +6529,7 @@ bool bvhIntersectFogVolumeHit(
 				bool useAlphaTest = alphaTest != 0.0;
 				float transmissionFactor = ( 1.0 - metalness ) * transmission;
 				if (
-					transmissionFactor < rand() && ! (
+					transmissionFactor < rand( 9 ) && ! (
 						// material sidedness
 						material.side != 0.0 && surfaceHit.side == material.side
 
@@ -6534,11 +6537,12 @@ bool bvhIntersectFogVolumeHit(
 						|| useAlphaTest && albedo.a < alphaTest
 
 						// opacity
-						|| material.transparent && ! useAlphaTest && albedo.a < rand()
+						|| material.transparent && ! useAlphaTest && albedo.a < rand( 10 )
 					)
 				) {
 
-					return true;
+					result = true;
+					break;
 
 				}
 
@@ -6564,13 +6568,16 @@ bool bvhIntersectFogVolumeHit(
 
 			} else {
 
-				return false;
+				result = false;
+				break;
 
 			}
 
 		}
 
-		return true;
+		// reset the bounce index
+		sobolBounceIndex = originalBounceIndex;
+		return result;
 
 	}
 
@@ -6601,7 +6608,7 @@ bool bvhIntersectFogVolumeHit(
 
 			// offset the distance so we don't run into issues with particles on the same surface
 			// as other objects
-			float particleDist = intersectFogVolume( fogMaterial, sobol( 1 ) );
+			float particleDist = intersectFogVolume( fogMaterial, rand( 1 ) );
 			if ( particleDist + RAY_OFFSET < surfaceHit.dist ) {
 
 				surfaceHit.side = 1.0;
@@ -6664,6 +6671,7 @@ bool bvhIntersectFogVolumeHit(
 
 			vec3 uvPrime = material.mapTransform * vec3( uv, 1 );
 			albedo *= texture2D( textures, vec3( uvPrime.xy, material.map ) );
+
 		}
 
 		if ( material.vertexColors ) {
@@ -6695,7 +6703,7 @@ bool bvhIntersectFogVolumeHit(
 			|| useAlphaTest && albedo.a < alphaTest
 
 			// opacity
-			|| material.transparent && ! useAlphaTest && albedo.a < sobol( 3 )
+			|| material.transparent && ! useAlphaTest && albedo.a < rand( 3 )
 		) {
 
 			return SKIP_SURFACE;
@@ -6957,10 +6965,10 @@ bool bvhIntersectFogVolumeHit(
 		vec3 result = vec3( 0.0 );
 
 		// uniformly pick a light or environment map
-		if( lightsDenom != 0.0 && sobol( 5 ) < float( lights.count ) / lightsDenom ) {
+		if( lightsDenom != 0.0 && rand( 5 ) < float( lights.count ) / lightsDenom ) {
 
 			// sample a light or environment
-			LightRecord lightRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin, sobol3( 6 ) );
+			LightRecord lightRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin, rand3( 6 ) );
 
 			bool isSampleBelowSurface = ! surf.volumeParticle && dot( surf.faceNormal, lightRec.direction ) < 0.0;
 			if ( isSampleBelowSurface ) {
@@ -6995,11 +7003,11 @@ bool bvhIntersectFogVolumeHit(
 
 			}
 
-		} else {
+		} else if ( envMapInfo.totalSum != 0.0 && environmentIntensity != 0.0 ) {
 
 			// find a sample in the environment map to include in the contribution
 			vec3 envColor, envDirection;
-			float envPdf = sampleEquirectProbability( sobol2( 7 ), envColor, envDirection );
+			float envPdf = sampleEquirectProbability( rand2( 7 ), envColor, envDirection );
 			envDirection = invEnvRotation3x3 * envDirection;
 
 			// this env sampling is not set up for transmissive sampling and yields overly bright
@@ -7048,6 +7056,667 @@ bool bvhIntersectFogVolumeHit(
 
 `;
 
+	const stratifiedTextureGLSL = /* glsl */`
+
+	uniform sampler2D stratifiedTexture;
+	uniform sampler2D stratifiedOffsetTexture;
+
+	uint sobolPixelIndex = 0u;
+	uint sobolPathIndex = 0u;
+	uint sobolBounceIndex = 0u;
+	vec4 pixelSeed = vec4( 0 );
+
+	vec4 rand4( int v ) {
+
+		ivec2 uv = ivec2( v, sobolBounceIndex );
+		vec4 stratifiedSample = texelFetch( stratifiedTexture, uv, 0 );
+		return fract( stratifiedSample + pixelSeed.r ); // blue noise + stratified samples
+
+	}
+
+	vec3 rand3( int v ) {
+
+		return rand4( v ).xyz;
+
+	}
+
+	vec2 rand2( int v ) {
+
+		return rand4( v ).xy;
+
+	}
+
+	float rand( int v ) {
+
+		return rand4( v ).x;
+
+	}
+
+	void rng_initialize( vec2 screenCoord, int frame ) {
+
+		// tile the small noise texture across the entire screen
+		ivec2 noiseSize = ivec2( textureSize( stratifiedOffsetTexture, 0 ) );
+		pixelSeed = texelFetch( stratifiedOffsetTexture, ivec2( screenCoord.xy ) % noiseSize, 0 );
+
+	}
+
+`;
+
+	// Stratified Sampling based on implementation from hoverinc pathtracer
+	// - https://github.com/hoverinc/ray-tracing-renderer
+	// - http://www.pbr-book.org/3ed-2018/Sampling_and_Reconstruction/Stratified_Sampling.html
+
+	function shuffle( arr ) {
+
+		for ( let i = arr.length - 1; i > 0; i -- ) {
+
+		  const j = Math.floor( Math.random() * ( i + 1 ) );
+		  const x = arr[ i ];
+		  arr[ i ] = arr[ j ];
+		  arr[ j ] = x;
+
+		}
+
+		return arr;
+
+	}
+
+	// strataCount : The number of bins per dimension
+	// dimensions  : The number of dimensions to generate stratified values for
+	class StratifiedSampler {
+
+		constructor( strataCount, dimensions ) {
+
+			const l = strataCount ** dimensions;
+			const strata = new Uint16Array( l );
+			let index = l;
+
+			// each integer represents a statum bin
+			for ( let i = 0; i < l; i ++ ) {
+
+				strata[ i ] = i;
+
+			}
+
+			this.samples = new Float32Array( dimensions );
+
+			this.strataCount = strataCount;
+
+			this.restart = function () {
+
+				index = 0;
+
+			};
+
+			this.next = function () {
+
+				const { samples } = this;
+
+				if ( index >= strata.length ) {
+
+					shuffle( strata );
+					this.restart();
+
+				}
+
+				let stratum = strata[ index ++ ];
+
+				for ( let i = 0; i < dimensions; i ++ ) {
+
+					samples[ i ] = ( stratum % strataCount + Math.random() ) / strataCount;
+					stratum = Math.floor( stratum / strataCount );
+
+				}
+
+				return samples;
+
+			};
+
+		}
+
+	}
+
+	// Stratified Sampling based on implementation from hoverinc pathtracer
+
+	// Stratified set of data with each tuple stratified separately and combined
+	class StratifiedSamplerCombined {
+
+		constructor( strataCount, listOfDimensions ) {
+
+			let totalDim = 0;
+			for ( const dim of listOfDimensions ) {
+
+				totalDim += dim;
+
+			}
+
+			const combined = new Float32Array( totalDim );
+			const strataObjs = [];
+			let offset = 0;
+			for ( const dim of listOfDimensions ) {
+
+				const sampler = new StratifiedSampler( strataCount, dim );
+				sampler.samples = new Float32Array( combined.buffer, offset, sampler.samples.length );
+				offset += sampler.samples.length * 4;
+				strataObjs.push( sampler );
+
+			}
+
+			this.samples = combined;
+
+			this.strataCount = strataCount;
+
+			this.next = function () {
+
+				for ( const strata of strataObjs ) {
+
+					strata.next();
+
+				}
+
+				return combined;
+
+			};
+
+			this.restart = function () {
+
+				for ( const strata of strataObjs ) {
+
+					strata.restart();
+
+				}
+
+			};
+
+		}
+
+	}
+
+	class StratifiedSamplesTexture extends three.DataTexture {
+
+		constructor( count = 1, depth = 1, strata = 8 ) {
+
+			super( new Float32Array( 1 ), 1, 1, three.RGBAFormat, three.FloatType );
+			this.minFilter = three.NearestFilter;
+			this.magFilter = three.NearestFilter;
+
+			this.strata = strata;
+			this.sampler = null;
+
+			this.init( count, depth, strata );
+
+		}
+
+		init( count, depth, strata = this.strata ) {
+
+			const { image } = this;
+			if ( image.width === depth && image.height === count ) {
+
+				return;
+
+			}
+
+			const dimensions = new Array( count * depth ).fill( 4 );
+			const sampler = new StratifiedSamplerCombined( strata, dimensions );
+
+			image.width = depth;
+			image.height = count;
+			image.data = sampler.samples;
+
+			this.sampler = sampler;
+
+			this.dispose();
+			this.next();
+
+		}
+
+		next() {
+
+			this.sampler.next();
+			this.needsUpdate = true;
+
+		}
+
+	}
+
+	function shuffleArray( array, random = Math.random ) {
+
+		for ( let i = array.length - 1; i > 0; i -- ) {
+
+			const replaceIndex = ~ ~ ( ( random() - 1e-6 ) * i );
+			const tmp = array[ i ];
+			array[ i ] = array[ replaceIndex ];
+			array[ replaceIndex ] = tmp;
+
+		}
+
+	}
+
+	function fillWithOnes( array, count ) {
+
+		array.fill( 0 );
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			array[ i ] = 1;
+
+		}
+
+	}
+
+	class BlueNoiseSamples {
+
+		constructor( size ) {
+
+			this.count = 0;
+			this.size = - 1;
+			this.sigma = - 1;
+			this.radius = - 1;
+			this.lookupTable = null;
+			this.score = null;
+			this.binaryPattern = null;
+
+			this.resize( size );
+			this.setSigma( 1.5 );
+
+		}
+
+		findVoid() {
+
+			const { score, binaryPattern } = this;
+
+			let currValue = Infinity;
+			let currIndex = - 1;
+			for ( let i = 0, l = binaryPattern.length; i < l; i ++ ) {
+
+				if ( binaryPattern[ i ] !== 0 ) {
+
+					continue;
+
+				}
+
+				const pScore = score[ i ];
+				if ( pScore < currValue ) {
+
+					currValue = pScore;
+					currIndex = i;
+
+				}
+
+			}
+
+			return currIndex;
+
+		}
+
+		findCluster() {
+
+			const { score, binaryPattern } = this;
+
+			let currValue = - Infinity;
+			let currIndex = - 1;
+			for ( let i = 0, l = binaryPattern.length; i < l; i ++ ) {
+
+				if ( binaryPattern[ i ] !== 1 ) {
+
+					continue;
+
+				}
+
+				const pScore = score[ i ];
+				if ( pScore > currValue ) {
+
+					currValue = pScore;
+					currIndex = i;
+
+				}
+
+			}
+
+			return currIndex;
+
+		}
+
+		setSigma( sigma ) {
+
+			if ( sigma === this.sigma ) {
+
+				return;
+
+			}
+
+			// generate a radius in which the score will be updated under the
+			// assumption that e^-10 is insignificant enough to be the border at
+			// which we drop off.
+			const radius = ~ ~ ( Math.sqrt( 10 * 2 * ( sigma ** 2 ) ) + 1 );
+			const lookupWidth = 2 * radius + 1;
+			const lookupTable = new Float32Array( lookupWidth * lookupWidth );
+			const sigma2 = sigma * sigma;
+			for ( let x = - radius; x <= radius; x ++ ) {
+
+				for ( let y = - radius; y <= radius; y ++ ) {
+
+					const index = ( radius + y ) * lookupWidth + x + radius;
+					const dist2 = x * x + y * y;
+					lookupTable[ index ] = Math.E ** ( - dist2 / ( 2 * sigma2 ) );
+
+				}
+
+			}
+
+			this.lookupTable = lookupTable;
+			this.sigma = sigma;
+			this.radius = radius;
+
+		}
+
+		resize( size ) {
+
+			if ( this.size !== size ) {
+
+				this.size = size;
+				this.score = new Float32Array( size * size );
+				this.binaryPattern = new Uint8Array( size * size );
+
+			}
+
+
+		}
+
+		invert() {
+
+			const { binaryPattern, score, size } = this;
+
+			score.fill( 0 );
+
+			for ( let i = 0, l = binaryPattern.length; i < l; i ++ ) {
+
+				if ( binaryPattern[ i ] === 0 ) {
+
+					const y = ~ ~ ( i / size );
+					const x = i - y * size;
+					this.updateScore( x, y, 1 );
+					binaryPattern[ i ] = 1;
+
+				} else {
+
+					binaryPattern[ i ] = 0;
+
+				}
+
+			}
+
+		}
+
+		updateScore( x, y, multiplier ) {
+
+			// TODO: Is there a way to keep track of the highest and lowest scores here to avoid have to search over
+			// everything in the buffer?
+			const { size, score, lookupTable } = this;
+
+			// const sigma2 = sigma * sigma;
+			// const radius = Math.floor( size / 2 );
+			const radius = this.radius;
+			const lookupWidth = 2 * radius + 1;
+			for ( let px = - radius; px <= radius; px ++ ) {
+
+				for ( let py = - radius; py <= radius; py ++ ) {
+
+					// const dist2 = px * px + py * py;
+					// const value = Math.E ** ( - dist2 / ( 2 * sigma2 ) );
+
+					const lookupIndex = ( radius + py ) * lookupWidth + px + radius;
+					const value = lookupTable[ lookupIndex ];
+
+					let sx = ( x + px );
+					sx = sx < 0 ? size + sx : sx % size;
+
+					let sy = ( y + py );
+					sy = sy < 0 ? size + sy : sy % size;
+
+					const sindex = sy * size + sx;
+					score[ sindex ] += multiplier * value;
+
+				}
+
+			}
+
+		}
+
+		addPointIndex( index ) {
+
+			this.binaryPattern[ index ] = 1;
+
+			const size = this.size;
+			const y = ~ ~ ( index / size );
+			const x = index - y * size;
+			this.updateScore( x, y, 1 );
+			this.count ++;
+
+		}
+
+		removePointIndex( index ) {
+
+			this.binaryPattern[ index ] = 0;
+
+			const size = this.size;
+			const y = ~ ~ ( index / size );
+			const x = index - y * size;
+			this.updateScore( x, y, - 1 );
+			this.count --;
+
+		}
+
+		copy( source ) {
+
+			this.resize( source.size );
+			this.score.set( source.score );
+			this.binaryPattern.set( source.binaryPattern );
+			this.setSigma( source.sigma );
+			this.count = source.count;
+
+		}
+
+	}
+
+	class BlueNoiseGenerator {
+
+		constructor() {
+
+			this.random = Math.random;
+			this.sigma = 1.5;
+			this.size = 64;
+			this.majorityPointsRatio = 0.1;
+
+			this.samples = new BlueNoiseSamples( 1 );
+			this.savedSamples = new BlueNoiseSamples( 1 );
+
+		}
+
+		generate() {
+
+			// http://cv.ulichney.com/papers/1993-void-cluster.pdf
+
+			const {
+				samples,
+				savedSamples,
+				sigma,
+				majorityPointsRatio,
+				size,
+			} = this;
+
+			samples.resize( size );
+			samples.setSigma( sigma );
+
+			// 1. Randomly place the minority points.
+			const pointCount = Math.floor( size * size * majorityPointsRatio );
+			const initialSamples = samples.binaryPattern;
+
+			fillWithOnes( initialSamples, pointCount );
+			shuffleArray( initialSamples, this.random );
+
+			for ( let i = 0, l = initialSamples.length; i < l; i ++ ) {
+
+				if ( initialSamples[ i ] === 1 ) {
+
+					samples.addPointIndex( i );
+
+				}
+
+			}
+
+			// 2. Remove minority point that is in densest cluster and place it in the largest void.
+			while ( true ) {
+
+				const clusterIndex = samples.findCluster();
+				samples.removePointIndex( clusterIndex );
+
+				const voidIndex = samples.findVoid();
+				if ( clusterIndex === voidIndex ) {
+
+					samples.addPointIndex( clusterIndex );
+					break;
+
+				}
+
+				samples.addPointIndex( voidIndex );
+
+			}
+
+			// 3. PHASE I: Assign a rank to each progressively less dense cluster point and put it
+			// in the dither array.
+			const ditherArray = new Uint32Array( size * size );
+			savedSamples.copy( samples );
+
+			let rank;
+			rank = samples.count - 1;
+			while ( rank >= 0 ) {
+
+				const clusterIndex = samples.findCluster();
+				samples.removePointIndex( clusterIndex );
+
+				ditherArray[ clusterIndex ] = rank;
+				rank --;
+
+			}
+
+			// 4. PHASE II: Do the same thing for the largest voids up to half of the total pixels using
+			// the initial binary pattern.
+			const totalSize = size * size;
+			rank = savedSamples.count;
+			while ( rank < totalSize / 2 ) {
+
+				const voidIndex = savedSamples.findVoid();
+				savedSamples.addPointIndex( voidIndex );
+				ditherArray[ voidIndex ] = rank;
+				rank ++;
+
+			}
+
+			// 5. PHASE III: Invert the pattern and finish out by assigning a rank to the remaining
+			// and iteratively removing them.
+			savedSamples.invert();
+
+			while ( rank < totalSize ) {
+
+				const clusterIndex = savedSamples.findCluster();
+				savedSamples.removePointIndex( clusterIndex );
+				ditherArray[ clusterIndex ] = rank;
+				rank ++;
+
+			}
+
+			return { data: ditherArray, maxValue: totalSize };
+
+		}
+
+	}
+
+	function getStride( channels ) {
+
+		if ( channels >= 3 ) {
+
+			return 4;
+
+		} else {
+
+			return channels;
+
+		}
+
+	}
+
+	function getFormat( channels ) {
+
+		switch ( channels ) {
+
+		case 1:
+			return three.RedFormat;
+		case 2:
+			return three.RGFormat;
+		default:
+			return three.RGBAFormat;
+
+		}
+
+	}
+
+	class BlueNoiseTexture extends three.DataTexture {
+
+		constructor( size = 64, channels = 1 ) {
+
+			super( new Float32Array( 4 ), 1, 1, three.RGBAFormat, three.FloatType );
+			this.minFilter = three.NearestFilter;
+			this.magFilter = three.NearestFilter;
+
+			this.size = size;
+			this.channels = channels;
+			this.update();
+
+		}
+
+		update() {
+
+			const channels = this.channels;
+			const size = this.size;
+			const generator = new BlueNoiseGenerator();
+			generator.channels = channels;
+			generator.size = size;
+
+			const stride = getStride( channels );
+			const format = getFormat( stride );
+			if ( this.image.width !== size || format !== this.format ) {
+
+				this.image.width = size;
+				this.image.height = size;
+				this.image.data = new Float32Array( ( size ** 2 ) * stride );
+				this.format = format;
+				this.dispose();
+
+			}
+
+			const data = this.image.data;
+			for ( let i = 0, l = channels; i < l; i ++ ) {
+
+				const result = generator.generate();
+				const bin = result.data;
+				const maxValue = result.maxValue;
+
+				for ( let j = 0, l2 = bin.length; j < l2; j ++ ) {
+
+					const value = bin[ j ] / maxValue;
+					data[ j * stride + i ] = value;
+
+				}
+
+			}
+
+			this.needsUpdate = true;
+
+		}
+
+	}
+
 	class PhysicalPathTracingMaterial extends MaterialBase {
 
 		onBeforeRender() {
@@ -7071,7 +7740,12 @@ bool bvhIntersectFogVolumeHit(
 					FEATURE_DOF: 1,
 					FEATURE_BACKGROUND_MAP: 0,
 					FEATURE_FOG: 1,
-					FEATURE_SOBOL: 0,
+
+					// 0 = PCG
+					// 1 = Sobol
+					// 2 = Stratified List
+					RANDOM_TYPE: 2,
+
 					// 0 = Perspective
 					// 1 = Orthographic
 					// 2 = Equirectangular
@@ -7113,6 +7787,8 @@ bool bvhIntersectFogVolumeHit(
 
 					backgroundAlpha: { value: 1.0 },
 					sobolTexture: { value: null },
+					stratifiedTexture: { value: new StratifiedSamplesTexture() },
+					stratifiedOffsetTexture: { value: new BlueNoiseTexture( 64, 1 ) },
 				},
 
 				vertexShader: /* glsl */`
@@ -7152,23 +7828,35 @@ bool bvhIntersectFogVolumeHit(
 				${ materialStructGLSL }
 
 				// random
-				${ pcgGLSL }
-				#if FEATURE_SOBOL
+				#if RANDOM_TYPE == 2 	// Stratified List
 
+					${ stratifiedTextureGLSL }
+
+				#elif RANDOM_TYPE == 1 	// Sobol
+
+					${ pcgGLSL }
 					${ sobolCommonGLSL }
 					${ sobolSamplingGLSL }
 
-				#else
+					#define rand(v) sobol(v)
+					#define rand2(v) sobol2(v)
+					#define rand3(v) sobol3(v)
+					#define rand4(v) sobol4(v)
+
+				#else 					// PCG
+
+					${ pcgGLSL }
 
 					// Using the sobol functions seems to break the the compiler on MacOS
 					// - specifically the "sobolReverseBits" function.
 					uint sobolPixelIndex = 0u;
 					uint sobolPathIndex = 0u;
 					uint sobolBounceIndex = 0u;
-					float sobol( int v ) { return rand(); }
-					vec2 sobol2( int v ) { return rand2(); }
-					vec3 sobol3( int v ) { return rand3(); }
-					vec4 sobol4( int v ) { return rand4(); }
+
+					#define rand(v) pcgRand()
+					#define rand2(v) pcgRand2()
+					#define rand3(v) pcgRand3()
+					#define rand4(v) pcgRand4()
 
 				#endif
 
@@ -7286,7 +7974,10 @@ bool bvhIntersectFogVolumeHit(
 					// inverse environment rotation
 					envRotation3x3 = mat3( environmentRotation );
 					invEnvRotation3x3 = inverse( envRotation3x3 );
-					lightsDenom = environmentIntensity == 0.0 && lights.count != 0u ? float( lights.count ) : float( lights.count + 1u );
+					lightsDenom =
+						( environmentIntensity == 0.0 || envMapInfo.totalSum == 0.0 ) && lights.count != 0u ?
+							float( lights.count ) :
+							float( lights.count + 1u );
 
 					// final color
 					gl_FragColor = vec4( 0, 0, 0, 1 );
@@ -7355,7 +8046,7 @@ bool bvhIntersectFogVolumeHit(
 
 							if ( state.firstRay || state.transmissiveRay ) {
 
-								gl_FragColor.rgb += sampleBackground( envRotation3x3 * ray.direction, sobol2( 2 ) ) * state.throughputColor;
+								gl_FragColor.rgb += sampleBackground( envRotation3x3 * ray.direction, rand2( 2 ) ) * state.throughputColor;
 								gl_FragColor.a = backgroundAlpha;
 
 							} else {
@@ -7446,7 +8137,7 @@ bool bvhIntersectFogVolumeHit(
 						}
 
 						scatterRec = bsdfSample( - ray.direction, surf );
-						state.isShadowRay = scatterRec.specularPdf < sobol( 4 );
+						state.isShadowRay = scatterRec.specularPdf < rand( 4 );
 
 						bool isBelowSurface = ! surf.volumeParticle && dot( scatterRec.direction, surf.faceNormal ) < 0.0;
 						vec3 hitPoint = stepRayOrigin( ray.origin, ray.direction, isBelowSurface ? - surf.faceNormal : surf.faceNormal, surfaceHit.dist );
@@ -7516,7 +8207,7 @@ bool bvhIntersectFogVolumeHit(
 						rrProb = sqrt( rrProb );
 						rrProb = max( rrProb, depthProb );
 						rrProb = min( rrProb, 1.0 );
-						if ( sobol( 8 ) > rrProb ) {
+						if ( rand( 8 ) > rrProb ) {
 
 							break;
 
@@ -7947,10 +8638,9 @@ bool bvhIntersectFogVolumeHit(
 	exports.QuiltPathTracingRenderer = QuiltPathTracingRenderer;
 	exports.RenderTarget2DArray = RenderTarget2DArray;
 	exports.ShapedAreaLight = ShapedAreaLight;
+	exports.getDummyMesh = getDummyMesh;
 	exports.getGroupMaterialIndicesAttribute = getGroupMaterialIndicesAttribute;
-	exports.mergeMeshes = mergeMeshes;
 	exports.setCommonAttributes = setCommonAttributes;
-	exports.trimToAttributes = trimToAttributes;
 
 	Object.defineProperty(exports, '__esModule', { value: true });