three-gpu-pathtracer 0.0.17 → 0.0.19

package/build/index.module.js

@@ -1,7 +1,7 @@
-import { ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, Vector4, NormalBlending, Color, HalfFloatType, Vector3, MathUtils, Matrix4, PerspectiveCamera, BufferAttribute, Mesh, BufferGeometry, Camera, SpotLight, RectAreaLight, Spherical, DataTexture, EquirectangularReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, LinearFilter, DataUtils, DoubleSide, BackSide, FrontSide, WebGLArrayRenderTarget, UnsignedByteType, MeshBasicMaterial, NoToneMapping, Source, RedFormat, Quaternion, Loader, FileLoader, PMREMGenerator, DataArrayTexture, MeshStandardMaterial, BoxGeometry } from 'three';
+import { ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, Vector4, NormalBlending, Color, HalfFloatType, Vector3, MathUtils, Matrix4, PerspectiveCamera, BufferAttribute, MeshBasicMaterial, BufferGeometry, Mesh, Camera, SpotLight, RectAreaLight, Spherical, DataTexture, EquirectangularReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, LinearFilter, DoubleSide, BackSide, FrontSide, WebGLArrayRenderTarget, UnsignedByteType, NoToneMapping, DataUtils, Source, RedFormat, Quaternion, Loader, FileLoader, PMREMGenerator, DataArrayTexture, RGFormat, MeshStandardMaterial, BoxGeometry } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
-import { StaticGeometryGenerator, SAH, MeshBVH, FloatVertexAttributeTexture, MeshBVHUniformStruct, UIntVertexAttributeTexture, BVHShaderGLSL } from 'three-mesh-bvh';
-import { mergeVertices, mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { StaticGeometryGenerator, MeshBVH, SAH, FloatVertexAttributeTexture, MeshBVHUniformStruct, UIntVertexAttributeTexture, BVHShaderGLSL } from 'three-mesh-bvh';
+import { mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 
 class MaterialBase extends ShaderMaterial {
 
@@ -456,9 +456,6 @@ class SobolNumberMapGenerator {
 
 }
 
-const _scissor = new Vector4();
-const _viewport = new Vector4();
-
 function* renderTask() {
 
 	const {
@@ -500,12 +497,21 @@ function* renderTask() {
 		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 ++ ) {
 
@@ -554,40 +560,28 @@ function* renderTask() {
 
 				}
 
+				// 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 );
 
@@ -1077,25 +1071,6 @@ function getGroupMaterialIndicesAttribute( geometry, materials, allMaterials ) {
 
 }
 
-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;
@@ -1113,6 +1088,13 @@ function setCommonAttributes( geometry, options ) {
 
 	}
 
+	if ( ! geometry.attributes.uv2 && ( attributes && attributes.includes( 'uv2' ) ) ) {
+
+		const vertCount = geometry.attributes.position.count;
+		geometry.setAttribute( 'uv2', new BufferAttribute( new Float32Array( vertCount * 2 ), 2, false ) );
+
+	}
+
 	if ( ! geometry.attributes.tangent && ( attributes && attributes.includes( 'tangent' ) ) ) {
 
 		if ( normalMapRequired ) {
@@ -1161,169 +1143,46 @@ function setCommonAttributes( geometry, options ) {
 
 }
 
-function mergeMeshes( meshes, options = {} ) {
-
-	options = { attributes: null, cloneGeometry: true, ...options };
+const dummyMaterial = new MeshBasicMaterial();
+function getDummyMesh() {
 
-	const transformedGeometry = [];
-	const materialSet = new Set();
-	for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+	const emptyGeometry = new BufferGeometry();
+	emptyGeometry.setAttribute( 'position', new BufferAttribute( new Float32Array( 9 ), 3 ) );
+	return new 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 = 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 StaticGeometryGenerator( c );
-					generator.attributes = [ 'position', 'color', 'normal', 'tangent', 'uv', 'uv2' ];
-					generator.applyWorldTransforms = false;
-					const mesh = new 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: SAH, ...options, maxLeafTris: 1 };
-		return {
-			scene,
-			materials,
-			textures,
-			lights,
-			bvh: new 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 BufferGeometry();
 		this.materials = null;
@@ -1347,64 +1206,75 @@ class DynamicPathTracingSceneGenerator {
 
 	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 );
+
+	}
+
+	generate() {
 
-			const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, materials, materials );
-			geometry.setAttribute( 'materialIndex', materialIndexAttribute );
-			geometry.clearGroups();
+		const { objects, staticGeometryGenerator, geometry, bvhOptions } = this;
+		if ( this.bvh === null ) {
 
-			this.bvh = new MeshBVH( geometry );
-			this.materials = materials;
-			this.textures = Array.from( textureSet );
+			this.prepScene();
+			this.bvh = new MeshBVH( geometry, { strategy: SAH, maxLeafTris: 1, ...bvhOptions } );
 
 			return {
 				lights: this.lights,
@@ -1434,6 +1304,30 @@ class DynamicPathTracingSceneGenerator {
 
 }
 
+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 ) {
@@ -1798,8 +1692,8 @@ class ProceduralEquirectTexture extends DataTexture {
 	constructor( width = 512, height = 512 ) {
 
 		super(
-			new Uint16Array( width * height * 4 ),
-			width, height, RGBAFormat, HalfFloatType, EquirectangularReflectionMapping,
+			new Float32Array( width * height * 4 ),
+			width, height, RGBAFormat, FloatType, EquirectangularReflectionMapping,
 			RepeatWrapping, ClampToEdgeWrapping, LinearFilter, LinearFilter,
 		);
 
@@ -1831,10 +1725,10 @@ class ProceduralEquirectTexture extends DataTexture {
 
 				const i = y * width + x;
 				const i4 = 4 * i;
-				data[ i4 + 0 ] = DataUtils.toHalfFloat( _color.r );
-				data[ i4 + 1 ] = DataUtils.toHalfFloat( _color.g );
-				data[ i4 + 2 ] = DataUtils.toHalfFloat( _color.b );
-				data[ i4 + 3 ] = DataUtils.toHalfFloat( 1.0 );
+				data[ i4 + 0 ] = ( _color.r );
+				data[ i4 + 1 ] = ( _color.g );
+				data[ i4 + 2 ] = ( _color.b );
+				data[ i4 + 3 ] = ( 1.0 );
 
 			}
 
@@ -1889,7 +1783,7 @@ class GradientEquirectTexture extends ProceduralEquirectTexture {
 // 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 }`;
 
 }
 
@@ -2101,7 +1995,7 @@ class MaterialsTexture extends DataTexture {
 
 		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
@@ -2439,7 +2333,7 @@ class RenderTarget2DArray extends WebGLArrayRenderTarget {
 
 		};
 
-		const fsQuad = new FullScreenQuad( new MeshBasicMaterial() );
+		const fsQuad = new FullScreenQuad( new CopyMaterial() );
 		this.fsQuad = fsQuad;
 
 	}
@@ -2474,7 +2368,6 @@ class RenderTarget2DArray extends WebGLArrayRenderTarget {
 				texture.matrix.identity();
 
 				fsQuad.material.map = texture;
-				fsQuad.material.transparent = true;
 
 				renderer.setRenderTarget( this, i );
 				fsQuad.render( renderer );
@@ -2504,6 +2397,54 @@ class RenderTarget2DArray extends WebGLArrayRenderTarget {
 
 }
 
+class CopyMaterial extends 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 );
@@ -2555,7 +2496,7 @@ function colorToLuminance( r, g, b ) {
 }
 
 // ensures the data is all floating point values and flipY is false
-function preprocessEnvMap( envMap ) {
+function preprocessEnvMap( envMap, targetType = HalfFloatType ) {
 
 	const map = envMap.clone();
 	map.source = new Source( { ...map.image } );
@@ -2564,17 +2505,54 @@ function preprocessEnvMap( envMap ) {
 	// 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 === HalfFloatType ) {
+	if ( map.type !== targetType ) {
+
+		if ( targetType === 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;
 
-		newData = new Uint16Array( data.length );
-		for ( const i in data ) {
+		} 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 === HalfFloatType ) {
+
+				v = DataUtils.fromHalfFloat( data[ i ] );
+
+			}
+
+			if ( map.type !== FloatType && map.type !== HalfFloatType ) {
+
+				v /= maxIntValue;
+
+			}
+
+			if ( targetType === HalfFloatType ) {
 
-			newData[ i ] = data[ i ];
+				newData[ i ] = DataUtils.toHalfFloat( v );
+
+			}
 
 		}
 
 		map.image.data = newData;
-		map.type = HalfFloatType;
+		map.type = targetType;
 
 	}
 
@@ -2666,7 +2644,7 @@ class EquirectHdrInfoUniform {
 		// https://pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Sampling_Light_Sources#InfiniteAreaLights
 		const map = preprocessEnvMap( hdr );
 		map.wrapS = RepeatWrapping;
-		map.wrapT = RepeatWrapping;
+		map.wrapT = ClampToEdgeWrapping;
 
 		const { width, height, data } = map.image;
 
@@ -2878,6 +2856,13 @@ class LightsInfoUniformStruct {
 			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 );
@@ -2942,7 +2927,7 @@ class LightsInfoUniformStruct {
 
 			} 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 );
@@ -2972,24 +2957,21 @@ class LightsInfoUniformStruct {
 				// 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 ) {
 
@@ -3006,7 +2988,7 @@ class LightsInfoUniformStruct {
 				index += 4;
 
 				// sample 5
-				index += 2;
+				index += 1;
 
 				floatArray[ baseIndex + ( index ++ ) ] = l.decay;
 				floatArray[ baseIndex + ( index ++ ) ] = l.distance;
@@ -4420,18 +4402,16 @@ const lightsStructGLSL = /* glsl */`
 			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;
 
@@ -5149,15 +5129,17 @@ const bsdfSamplingGLSL = /* glsl */`
 
 		// 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 );
 
@@ -5202,7 +5184,7 @@ const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
-			sobol2( 12 )
+			rand2( 12 )
 		);
 
 		// apply to new ray by reflecting off the new normal
@@ -5239,7 +5221,7 @@ const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( filteredRoughness ),
-			sobol2( 13 )
+			rand2( 13 )
 		);
 
 		vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
@@ -5261,7 +5243,8 @@ const bsdfSamplingGLSL = /* glsl */`
 		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;
@@ -5276,7 +5259,7 @@ const bsdfSamplingGLSL = /* glsl */`
 
 		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 ) {
@@ -5317,7 +5300,7 @@ const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
-			sobol2( 14 )
+			rand2( 14 )
 		);
 
 		// apply to new ray by reflecting off the new normal
@@ -5352,7 +5335,8 @@ const bsdfSamplingGLSL = /* glsl */`
 
 		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;
@@ -5468,7 +5452,7 @@ const bsdfSamplingGLSL = /* glsl */`
 			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;
 
@@ -5520,7 +5504,7 @@ const bsdfSamplingGLSL = /* glsl */`
 		vec3 wi;
 		vec3 clearcoatWi;
 
-		float r = sobol( 15 );
+		float r = rand( 15 );
 		if ( r <= cdf[0] ) { // diffuse
 
 			wi = diffuseDirection( wo, surf );
@@ -5604,10 +5588,17 @@ const equirectSamplingGLSL = /* glsl */`
 	// 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;
@@ -6159,32 +6150,38 @@ const fresnelGLSL = /* glsl */`
 
 	}
 
-	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 */`
@@ -6241,28 +6238,28 @@ const pcgGLSL = /* glsl */`
 	}
 
 	// 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 );
@@ -6335,7 +6332,7 @@ const cameraUtilsGLSL = /* glsl */`
 
 		// 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;
 
@@ -6380,7 +6377,7 @@ const cameraUtilsGLSL = /* glsl */`
 
 			// 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 );
@@ -6416,6 +6413,9 @@ const attenuateHitGLSL = /* glsl */`
 		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;
@@ -6428,22 +6428,25 @@ const attenuateHitGLSL = /* glsl */`
 
 		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;
 
 				}
 
@@ -6525,7 +6528,7 @@ const attenuateHitGLSL = /* glsl */`
 				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
 
@@ -6533,11 +6536,12 @@ const attenuateHitGLSL = /* glsl */`
 						|| useAlphaTest && albedo.a < alphaTest
 
 						// opacity
-						|| material.transparent && ! useAlphaTest && albedo.a < rand()
+						|| material.transparent && ! useAlphaTest && albedo.a < rand( 10 )
 					)
 				) {
 
-					return true;
+					result = true;
+					break;
 
 				}
 
@@ -6563,13 +6567,16 @@ const attenuateHitGLSL = /* glsl */`
 
 			} else {
 
-				return false;
+				result = false;
+				break;
 
 			}
 
 		}
 
-		return true;
+		// reset the bounce index
+		sobolBounceIndex = originalBounceIndex;
+		return result;
 
 	}
 
@@ -6600,7 +6607,7 @@ const traceSceneGLSL = /* glsl */`
 
 			// 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;
@@ -6663,6 +6670,7 @@ const getSurfaceRecordGLSL = /* glsl */`
 
 			vec3 uvPrime = material.mapTransform * vec3( uv, 1 );
 			albedo *= texture2D( textures, vec3( uvPrime.xy, material.map ) );
+
 		}
 
 		if ( material.vertexColors ) {
@@ -6694,7 +6702,7 @@ const getSurfaceRecordGLSL = /* glsl */`
 			|| useAlphaTest && albedo.a < alphaTest
 
 			// opacity
-			|| material.transparent && ! useAlphaTest && albedo.a < sobol( 3 )
+			|| material.transparent && ! useAlphaTest && albedo.a < rand( 3 )
 		) {
 
 			return SKIP_SURFACE;
@@ -6956,10 +6964,10 @@ const directLightContributionGLSL = /*glsl*/`
 		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 ) {
@@ -6994,11 +7002,11 @@ const directLightContributionGLSL = /*glsl*/`
 
 			}
 
-		} 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
@@ -7047,6 +7055,667 @@ const directLightContributionGLSL = /*glsl*/`
 
 `;
 
+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 DataTexture {
+
+	constructor( count = 1, depth = 1, strata = 8 ) {
+
+		super( new Float32Array( 1 ), 1, 1, RGBAFormat, FloatType );
+		this.minFilter = NearestFilter;
+		this.magFilter = 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 RedFormat;
+	case 2:
+		return RGFormat;
+	default:
+		return RGBAFormat;
+
+	}
+
+}
+
+class BlueNoiseTexture extends DataTexture {
+
+	constructor( size = 64, channels = 1 ) {
+
+		super( new Float32Array( 4 ), 1, 1, RGBAFormat, FloatType );
+		this.minFilter = NearestFilter;
+		this.magFilter = 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() {
@@ -7070,7 +7739,12 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				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
@@ -7112,6 +7786,8 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 				backgroundAlpha: { value: 1.0 },
 				sobolTexture: { value: null },
+				stratifiedTexture: { value: new StratifiedSamplesTexture() },
+				stratifiedOffsetTexture: { value: new BlueNoiseTexture( 64, 1 ) },
 			},
 
 			vertexShader: /* glsl */`
@@ -7151,23 +7827,35 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				${ 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
 
@@ -7285,7 +7973,10 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 					// 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 );
@@ -7354,7 +8045,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 							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 {
@@ -7445,7 +8136,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						}
 
 						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 );
@@ -7515,7 +8206,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						rrProb = sqrt( rrProb );
 						rrProb = max( rrProb, depthProb );
 						rrProb = min( rrProb, 1.0 );
-						if ( sobol( 8 ) > rrProb ) {
+						if ( rand( 8 ) > rrProb ) {
 
 							break;
 
@@ -7920,5 +8611,5 @@ class CompatibilityDetector {
 
 // core
 
-export { BlurredEnvMapGenerator, CompatibilityDetector, DenoiseMaterial, DynamicPathTracingSceneGenerator, EquirectCamera, EquirectHdrInfoUniform, FogVolumeMaterial, GradientEquirectTexture, GradientMapMaterial, GraphMaterial, IESLoader, IESProfilesTexture, LightsInfoUniformStruct, MaterialBase, MaterialReducer, MaterialsTexture, PathTracingRenderer, PathTracingSceneGenerator, PhysicalCamera, PhysicalCameraUniform, PhysicalPathTracingMaterial, PhysicalSpotLight, ProceduralEquirectTexture, QuiltPathTracingRenderer, RenderTarget2DArray, ShapedAreaLight, getGroupMaterialIndicesAttribute, mergeMeshes, setCommonAttributes, trimToAttributes };
+export { BlurredEnvMapGenerator, CompatibilityDetector, DenoiseMaterial, DynamicPathTracingSceneGenerator, EquirectCamera, EquirectHdrInfoUniform, FogVolumeMaterial, GradientEquirectTexture, GradientMapMaterial, GraphMaterial, IESLoader, IESProfilesTexture, LightsInfoUniformStruct, MaterialBase, MaterialReducer, MaterialsTexture, PathTracingRenderer, PathTracingSceneGenerator, PhysicalCamera, PhysicalCameraUniform, PhysicalPathTracingMaterial, PhysicalSpotLight, ProceduralEquirectTexture, QuiltPathTracingRenderer, RenderTarget2DArray, ShapedAreaLight, getDummyMesh, getGroupMaterialIndicesAttribute, setCommonAttributes };
 //# sourceMappingURL=index.module.js.map