three-gpu-pathtracer 0.0.16 → 0.0.18

package/build/index.umd.cjs

@@ -340,9 +340,9 @@
 
 	// Seeds
 	uniform sampler2D sobolTexture;
-	uint sobolPixelIndex;
-	uint sobolPathIndex;
-	uint sobolBounceIndex;
+	uint sobolPixelIndex = 0u;
+	uint sobolPathIndex = 0u;
+	uint sobolBounceIndex = 0u;
 
 	uint sobolGetSeed( uint bounce, uint effect ) {
 
@@ -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 );
 
@@ -704,18 +698,22 @@
 			this._currentTile = 0;
 
 			this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
+
+			// will be null if extension not supported
+			const floatLinearExtensionSupported = renderer.extensions.get( 'OES_texture_float_linear' );
+
 			this._primaryTarget = new three.WebGLRenderTarget( 1, 1, {
 				format: three.RGBAFormat,
-				type: three.FloatType,
+				type: floatLinearExtensionSupported ? three.FloatType : three.HalfFloatType,
 			} );
 			this._blendTargets = [
 				new three.WebGLRenderTarget( 1, 1, {
 					format: three.RGBAFormat,
-					type: three.FloatType,
+					type: floatLinearExtensionSupported ? three.FloatType : three.HalfFloatType,
 				} ),
 				new three.WebGLRenderTarget( 1, 1, {
 					format: three.RGBAFormat,
-					type: three.FloatType,
+					type: floatLinearExtensionSupported ? three.FloatType : three.HalfFloatType,
 				} ),
 			];
 
@@ -1074,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;
@@ -1110,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 ) {
@@ -1158,158 +1144,46 @@
 
 	}
 
-	function mergeMeshes( meshes, options = {} ) {
-
-		options = { attributes: null, cloneGeometry: true, ...options };
-
-		const transformedGeometry = [];
-		const materialSet = new Set();
-		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
-
-			// 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;
+	const dummyMaterial = new three.MeshBasicMaterial();
+	function getDummyMesh() {
 
-			mesh.updateMatrixWorld();
+		const emptyGeometry = new three.BufferGeometry();
+		emptyGeometry.setAttribute( 'position', new three.BufferAttribute( new Float32Array( 9 ), 3 ) );
+		return new three.Mesh( emptyGeometry, dummyMaterial );
 
-			// apply the matrix world to the geometry
-			const originalGeometry = meshes[ i ].geometry;
-			const geometry = options.cloneGeometry ? originalGeometry.clone() : originalGeometry;
-			geometry.applyMatrix4( mesh.matrixWorld );
+	}
 
-			// 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 ) {
-
-				const value = material[ key ];
-				if ( value && value.isTexture ) {
+		constructor( objects ) {
 
-					textureSet.add( value );
+			// ensure the objects is an array
+			if ( ! Array.isArray( objects ) ) {
 
-				}
+				objects = [ objects ];
 
 			}
 
-		} );
-
-		const geometry = BufferGeometryUtils_js.mergeBufferGeometries( transformedGeometry, false );
-		const textures = Array.from( textureSet );
-		return { geometry, materials, textures };
-
-	}
-
-	class PathTracingSceneGenerator {
-
-		prepScene( scene ) {
-
-			scene = Array.isArray( scene ) ? scene : [ scene ];
+			// use a dummy object for a fallback
+			const finalObjects = [ ...objects ];
+			if ( finalObjects.length === 0 ) {
 
-			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.isDirectionalLight || c.isPointLight ) {
-
-						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;
@@ -1333,59 +1207,75 @@
 
 		dispose() {}
 
-		generate() {
+		prepScene() {
 
-			const { objects, staticGeometryGenerator, geometry } = 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 ) {
+						const normalMapRequired = ! ! c.material.normalMap;
+						setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
 
-							this.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,
@@ -1415,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 ) {
@@ -1776,7 +1690,7 @@
 	const _color = new three.Color();
 	class ProceduralEquirectTexture extends three.DataTexture {
 
-		constructor( width, height ) {
+		constructor( width = 512, height = 512 ) {
 
 			super(
 				new Float32Array( width * height * 4 ),
@@ -1812,10 +1726,10 @@
 
 					const i = y * width + x;
 					const i4 = 4 * i;
-					data[ i4 + 0 ] = _color.r;
-					data[ i4 + 1 ] = _color.g;
-					data[ i4 + 2 ] = _color.b;
-					data[ i4 + 3 ] = 1.0;
+					data[ i4 + 0 ] = ( _color.r );
+					data[ i4 + 1 ] = ( _color.g );
+					data[ i4 + 2 ] = ( _color.b );
+					data[ i4 + 3 ] = ( 1.0 );
 
 				}
 
@@ -1870,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 }`;
 
 	}
 
@@ -1949,6 +1863,8 @@
 			this.type = three.FloatType;
 			this.wrapS = three.ClampToEdgeWrapping;
 			this.wrapT = three.ClampToEdgeWrapping;
+			this.minFilter = three.NearestFilter;
+			this.magFilter = three.NearestFilter;
 			this.generateMipmaps = false;
 			this.threeCompatibilityTransforms = false;
 			this.features = new MaterialFeatures();
@@ -2418,7 +2334,7 @@
 
 			};
 
-			const fsQuad = new Pass_js.FullScreenQuad( new three.MeshBasicMaterial() );
+			const fsQuad = new Pass_js.FullScreenQuad( new CopyMaterial() );
 			this.fsQuad = fsQuad;
 
 		}
@@ -2453,7 +2369,6 @@
 					texture.matrix.identity();
 
 					fsQuad.material.map = texture;
-					fsQuad.material.transparent = true;
 
 					renderer.setRenderTarget( this, i );
 					fsQuad.render( renderer );
@@ -2483,6 +2398,67 @@
 
 	}
 
+	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 );
+		for ( let i = 0, n = f32Array.length; i < n; ++ i ) {
+
+			f16Array[ i ] = three.DataUtils.toHalfFloat( f32Array[ i ] );
+
+		}
+
+		return f16Array;
+
+	}
+
 	function binarySearchFindClosestIndexOf( array, targetValue, offset = 0, count = array.length ) {
 
 		let lower = offset;
@@ -2521,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 } );
@@ -2530,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 ++ ) {
 
-			newData = new Float32Array( data.length );
-			for ( const i in data ) {
+				let v = data[ i ];
+				if ( map.type === three.HalfFloatType ) {
 
-				newData[ i ] = three.DataUtils.fromHalfFloat( data[ i ] );
+					v = three.DataUtils.fromHalfFloat( data[ i ] );
+
+				}
+
+				if ( map.type !== three.FloatType && map.type !== three.HalfFloatType ) {
+
+					v /= maxIntValue;
+
+				}
+
+				if ( targetType === three.HalfFloatType ) {
+
+					newData[ i ] = three.DataUtils.toHalfFloat( v );
+
+				}
 
 			}
 
 			map.image.data = newData;
-			map.type = three.FloatType;
+			map.type = targetType;
 
 		}
 
@@ -2581,8 +2594,8 @@
 
 			// Default to a white texture and associated weights so we don't
 			// just render black initially.
-			const whiteTex = new three.DataTexture( new Float32Array( [ 1, 1, 1, 1 ] ), 1, 1 );
-			whiteTex.type = three.FloatType;
+			const whiteTex = new three.DataTexture( toHalfFloatArray( new Float32Array( [ 1, 1, 1, 1 ] ) ), 1, 1 );
+			whiteTex.type = three.HalfFloatType;
 			whiteTex.format = three.RGBAFormat;
 			whiteTex.minFilter = three.LinearFilter;
 			whiteTex.magFilter = three.LinearFilter;
@@ -2593,8 +2606,8 @@
 
 			// Stores a map of [0, 1] value -> cumulative importance row & pdf
 			// used to sampling a random value to a relevant row to sample from
-			const marginalWeights = new three.DataTexture( new Float32Array( [ 0, 1 ] ), 1, 2 );
-			marginalWeights.type = three.FloatType;
+			const marginalWeights = new three.DataTexture( toHalfFloatArray( new Float32Array( [ 0, 1 ] ) ), 1, 2 );
+			marginalWeights.type = three.HalfFloatType;
 			marginalWeights.format = three.RedFormat;
 			marginalWeights.minFilter = three.LinearFilter;
 			marginalWeights.magFilter = three.LinearFilter;
@@ -2603,8 +2616,8 @@
 
 			// Stores a map of [0, 1] value -> cumulative importance column & pdf
 			// used to sampling a random value to a relevant pixel to sample from
-			const conditionalWeights = new three.DataTexture( new Float32Array( [ 0, 0, 1, 1 ] ), 2, 2 );
-			conditionalWeights.type = three.FloatType;
+			const conditionalWeights = new three.DataTexture( toHalfFloatArray( new Float32Array( [ 0, 0, 1, 1 ] ) ), 2, 2 );
+			conditionalWeights.type = three.HalfFloatType;
 			conditionalWeights.format = three.RedFormat;
 			conditionalWeights.minFilter = three.LinearFilter;
 			conditionalWeights.magFilter = three.LinearFilter;
@@ -2632,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;
 
@@ -2654,9 +2667,9 @@
 				for ( let x = 0; x < width; x ++ ) {
 
 					const i = y * width + x;
-					const r = data[ 4 * i + 0 ];
-					const g = data[ 4 * i + 1 ];
-					const b = data[ 4 * i + 2 ];
+					const r = three.DataUtils.fromHalfFloat( data[ 4 * i + 0 ] );
+					const g = three.DataUtils.fromHalfFloat( data[ 4 * i + 1 ] );
+					const b = three.DataUtils.fromHalfFloat( data[ 4 * i + 2 ] );
 
 					// the probability of the pixel being selected in this row is the
 					// scale of the luminance relative to the rest of the pixels.
@@ -2708,8 +2721,8 @@
 			// the marginal and conditional data. These will be used to sample with a random number
 			// to retrieve a uv value to sample in the environment map.
 			// These values continually increase so it's okay to interpolate between them.
-			const marginalDataArray = new Float32Array( height );
-			const conditionalDataArray = new Float32Array( width * height );
+			const marginalDataArray = new Uint16Array( height );
+			const conditionalDataArray = new Uint16Array( width * height );
 
 			// we add a half texel offset so we're sampling the center of the pixel
 			for ( let i = 0; i < height; i ++ ) {
@@ -2717,7 +2730,7 @@
 				const dist = ( i + 1 ) / height;
 				const row = binarySearchFindClosestIndexOf( cdfMarginal, dist );
 
-				marginalDataArray[ i ] = ( row + 0.5 ) / height;
+				marginalDataArray[ i ] = three.DataUtils.toHalfFloat( ( row + 0.5 ) / height );
 
 			}
 
@@ -2729,7 +2742,7 @@
 					const dist = ( x + 1 ) / width;
 					const col = binarySearchFindClosestIndexOf( cdfConditional, dist, y * width, width );
 
-					conditionalDataArray[ i ] = ( col + 0.5 ) / width;
+					conditionalDataArray[ i ] = three.DataUtils.toHalfFloat( ( col + 0.5 ) / width );
 
 				}
 
@@ -2803,6 +2816,8 @@
 			tex.wrapS = three.ClampToEdgeWrapping;
 			tex.wrapT = three.ClampToEdgeWrapping;
 			tex.generateMipmaps = false;
+			tex.minFilter = three.NearestFilter;
+			tex.magFilter = three.NearestFilter;
 
 			this.tex = tex;
 			this.count = 0;
@@ -2833,7 +2848,7 @@
 			const worldQuaternion = new three.Quaternion();
 			const eye = new three.Vector3();
 			const target = new three.Vector3();
-			const up = new three.Vector3();
+			const up = new three.Vector3( 0, 1, 0 );
 
 			for ( let i = 0, l = lights.length; i < l; i ++ ) {
 
@@ -2842,6 +2857,13 @@
 				const baseIndex = i * LIGHT_PIXELS * 4;
 				let index = 0;
 
+				// initialize to 0
+				for ( let p = 0; p < LIGHT_PIXELS; p ++ ) {
+
+					floatArray[ baseIndex + p ] = 0;
+
+				}
+
 				// sample 1
 			    // position
 				l.getWorldPosition( v );
@@ -2906,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 );
@@ -2936,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 ) {
 
@@ -2970,7 +2989,7 @@
 					index += 4;
 
 					// sample 5
-					index += 2;
+					index += 1;
 
 					floatArray[ baseIndex + ( index ++ ) ] = l.decay;
 					floatArray[ baseIndex + ( index ++ ) ] = l.distance;
@@ -3276,7 +3295,7 @@
 			loader.setPath( this.path );
 			loader.setRequestHeader( this.requestHeader );
 
-			const texture = new three.DataTexture( null, 360, 180, three.RedFormat, three.FloatType );
+			const texture = new three.DataTexture( null, 360, 180, three.RedFormat, three.HalfFloatType );
 			texture.minFilter = three.LinearFilter;
 			texture.magFilter = three.LinearFilter;
 
@@ -3284,7 +3303,7 @@
 
 				const iesLamp = new IESLamp( text );
 
-				texture.image.data = this._getIESValues( iesLamp );
+				texture.image.data = toHalfFloatArray( this._getIESValues( iesLamp ) );
 				texture.needsUpdate = true;
 
 				if ( onLoad !== undefined ) {
@@ -3302,10 +3321,10 @@
 		parse( text ) {
 
 			const iesLamp = new IESLamp( text );
-			const texture = new three.DataTexture( null, 360, 180, three.RedFormat, three.FloatType );
+			const texture = new three.DataTexture( null, 360, 180, three.RedFormat, three.HalfFloatType );
 			texture.minFilter = three.LinearFilter;
 			texture.magFilter = three.LinearFilter;
-			texture.image.data = this._getIESValues( iesLamp );
+			texture.image.data = toHalfFloatArray( this._getIESValues( iesLamp ) );
 			texture.needsUpdate = true;
 
 			return texture;
@@ -3323,7 +3342,7 @@
 
 			const tex = this.texture;
 			tex.format = three.RGBAFormat;
-			tex.type = three.FloatType;
+			tex.type = three.HalfFloatType;
 			tex.minFilter = three.LinearFilter;
 			tex.magFilter = three.LinearFilter;
 			tex.wrapS = three.ClampToEdgeWrapping;
@@ -3574,7 +3593,7 @@
 			this.renderer = renderer;
 			this.pmremGenerator = new three.PMREMGenerator( renderer );
 			this.copyQuad = new Pass_js.FullScreenQuad( new PMREMCopyMaterial() );
-			this.renderTarget = new three.WebGLRenderTarget( 1, 1, { type: three.FloatType, format: three.RGBAFormat } );
+			this.renderTarget = new three.WebGLRenderTarget( 1, 1, { type: three.HalfFloatType, format: three.RGBAFormat } );
 
 		}
 
@@ -3611,10 +3630,10 @@
 			renderer.autoClear = prevClear;
 
 			// read the data back
-			const buffer = new Float32Array( width * height * 4 );
+			const buffer = new Uint16Array( width * height * 4 );
 			renderer.readRenderTargetPixels( renderTarget, 0, 0, width, height, buffer );
 
-			const result = new three.DataTexture( buffer, width, height, three.RGBAFormat, three.FloatType );
+			const result = new three.DataTexture( buffer, width, height, three.RGBAFormat, three.HalfFloatType );
 			result.minFilter = texture.minFilter;
 			result.magFilter = texture.magFilter;
 			result.wrapS = texture.wrapS;
@@ -3756,7 +3775,7 @@
 
 					gl_FragColor = smartDeNoise( map, vec2( vUv.x, vUv.y ), sigma, kSigma, threshold );
 					#include <tonemapping_fragment>
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 					#include <premultiplied_alpha_fragment>
 
 				}
@@ -3839,7 +3858,7 @@
 					gl_FragColor.rgb = vec3( mix( minColor, maxColor, t ) );
 					gl_FragColor.a = 1.0;
 
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}`,
 
@@ -4048,7 +4067,7 @@
 
 					}
 
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}
 
@@ -4384,13 +4403,22 @@
 			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.penumbraCos = s5.r;
+			l.iesProfile = int( round( s5.g ) );
+
+		} else {
+
+			l.radius = 0.0;
+			l.decay = 0.0;
+			l.distance = 0.0;
 
-			l.coneCos = s5.r;
-			l.penumbraCos = s5.g;
-			l.iesProfile = int( round ( s5.b ) );
+			l.coneCos = 0.0;
+			l.penumbraCos = 0.0;
+			l.iesProfile = - 1;
 
 		}
 
@@ -4586,21 +4614,22 @@
 
 		uint firstTextureTransformIdx = i + 15u;
 
-		m.mapTransform = m.map == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx );
-		m.metalnessMapTransform = m.metalnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 2u );
-		m.roughnessMapTransform = m.roughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 4u );
-		m.transmissionMapTransform = m.transmissionMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 6u );
-		m.emissiveMapTransform = m.emissiveMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 8u );
-		m.normalMapTransform = m.normalMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 10u );
-		m.clearcoatMapTransform = m.clearcoatMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 12u );
-		m.clearcoatNormalMapTransform = m.clearcoatNormalMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 14u );
-		m.clearcoatRoughnessMapTransform = m.clearcoatRoughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 16u );
-		m.sheenColorMapTransform = m.sheenColorMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 18u );
-		m.sheenRoughnessMapTransform = m.sheenRoughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 20u );
-		m.iridescenceMapTransform = m.iridescenceMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 22u );
-		m.iridescenceThicknessMapTransform = m.iridescenceThicknessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 24u );
-		m.specularColorMapTransform = m.specularColorMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 26u );
-		m.specularIntensityMapTransform = m.specularIntensityMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 28u );
+		// mat3( 1.0 ) is an identity matrix
+		m.mapTransform = m.map == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx );
+		m.metalnessMapTransform = m.metalnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 2u );
+		m.roughnessMapTransform = m.roughnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 4u );
+		m.transmissionMapTransform = m.transmissionMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 6u );
+		m.emissiveMapTransform = m.emissiveMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 8u );
+		m.normalMapTransform = m.normalMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 10u );
+		m.clearcoatMapTransform = m.clearcoatMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 12u );
+		m.clearcoatNormalMapTransform = m.clearcoatNormalMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 14u );
+		m.clearcoatRoughnessMapTransform = m.clearcoatRoughnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 16u );
+		m.sheenColorMapTransform = m.sheenColorMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 18u );
+		m.sheenRoughnessMapTransform = m.sheenRoughnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 20u );
+		m.iridescenceMapTransform = m.iridescenceMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 22u );
+		m.iridescenceThicknessMapTransform = m.iridescenceThicknessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 24u );
+		m.specularColorMapTransform = m.specularColorMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 26u );
+		m.specularIntensityMapTransform = m.specularIntensityMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 28u );
 
 		return m;
 
@@ -4625,9 +4654,9 @@ bool isMaterialFogVolume( sampler2D materials, uint materialIndex ) {
 
 // returns true if we're within the first fog volume we hit
 bool bvhIntersectFogVolumeHit(
-	BVH bvh, vec3 rayOrigin, vec3 rayDirection,
+	vec3 rayOrigin, vec3 rayDirection,
 	usampler2D materialIndexAttribute, sampler2D materials,
-	out Material material
+	inout Material material
 ) {
 
 	material.fogVolume = false;
@@ -5087,7 +5116,7 @@ bool bvhIntersectFogVolumeHit(
 	${ iridescenceGLSL }
 
 	// diffuse
-	float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// https://schuttejoe.github.io/post/disneybsdf/
 		float fl = schlickFresnel( wi.z, 0.0 );
@@ -5101,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 );
 
@@ -5118,7 +5149,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 	// specular
-	float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// if roughness is set to 0 then D === NaN which results in black pixels
 		float metalness = surf.metalness;
@@ -5154,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
@@ -5165,7 +5196,7 @@ bool bvhIntersectFogVolumeHit(
 
 	// transmission
 	/*
-	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// See section 4.2 in https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf
 
@@ -5191,7 +5222,7 @@ bool bvhIntersectFogVolumeHit(
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( filteredRoughness ),
-			sobol2( 13 )
+			rand2( 13 )
 		);
 
 		vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
@@ -5208,12 +5239,13 @@ bool bvhIntersectFogVolumeHit(
 
 	// TODO: This is just using a basic cosine-weighted specular distribution with an
 	// incorrect PDF value at the moment. Update it to correctly use a GGX distribution
-	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		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;
@@ -5228,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 ) {
@@ -5269,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
@@ -5299,12 +5331,13 @@ bool bvhIntersectFogVolumeHit(
 	// bsdf
 	void getLobeWeights(
 		vec3 wo, vec3 wi, vec3 wh, vec3 clearcoatWo, SurfaceRecord surf,
-		out float diffuseWeight, out float specularWeight, out float transmissionWeight, out float clearcoatWeight
+		inout float diffuseWeight, inout float specularWeight, inout float transmissionWeight, inout float clearcoatWeight
 	) {
 
 		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;
@@ -5323,7 +5356,7 @@ bool bvhIntersectFogVolumeHit(
 
 	float bsdfEval(
 		vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRecord surf,
-		float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight, out float specularPdf, out vec3 color
+		float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight, inout float specularPdf, inout vec3 color
 	) {
 
 		float metalness = surf.metalness;
@@ -5386,7 +5419,7 @@ bool bvhIntersectFogVolumeHit(
 
 	}
 
-	float bsdfResult( vec3 worldWo, vec3 worldWi, SurfaceRecord surf, out vec3 color ) {
+	float bsdfResult( vec3 worldWo, vec3 worldWi, SurfaceRecord surf, inout vec3 color ) {
 
 		if ( surf.volumeParticle ) {
 
@@ -5420,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;
 
@@ -5472,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 );
@@ -5554,14 +5587,14 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 	// samples the color given env map with CDF and returns the pdf of the direction
-	float sampleEquirect( EquirectHdrInfo info, vec3 direction, out vec3 color ) {
+	float sampleEquirect( vec3 direction, inout vec3 color ) {
 
 		vec2 uv = equirectDirectionToUv( direction );
-		color = texture2D( info.map, uv ).rgb;
+		color = texture2D( envMapInfo.map, uv ).rgb;
 
-		float totalSum = info.totalSum;
+		float totalSum = envMapInfo.totalSum;
 		float lum = luminance( color );
-		ivec2 resolution = textureSize( info.map, 0 );
+		ivec2 resolution = textureSize( envMapInfo.map, 0 );
 		float pdf = lum / totalSum;
 
 		return float( resolution.x * resolution.y ) * pdf * equirectDirectionPdf( direction );
@@ -5569,20 +5602,20 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 	// samples a direction of the envmap with color and retrieves pdf
-	float sampleEquirectProbability( EquirectHdrInfo info, vec2 r, out vec3 color, out vec3 direction ) {
+	float sampleEquirectProbability( vec2 r, inout vec3 color, inout vec3 direction ) {
 
 		// sample env map cdf
-		float v = texture2D( info.marginalWeights, vec2( r.x, 0.0 ) ).x;
-		float u = texture2D( info.conditionalWeights, vec2( r.y, v ) ).x;
+		float v = texture2D( envMapInfo.marginalWeights, vec2( r.x, 0.0 ) ).x;
+		float u = texture2D( envMapInfo.conditionalWeights, vec2( r.y, v ) ).x;
 		vec2 uv = vec2( u, v );
 
 		vec3 derivedDirection = equirectUvToDirection( uv );
 		direction = derivedDirection;
-		color = texture2D( info.map, uv ).rgb;
+		color = texture2D( envMapInfo.map, uv ).rgb;
 
-		float totalSum = info.totalSum;
+		float totalSum = envMapInfo.totalSum;
 		float lum = luminance( color );
-		ivec2 resolution = textureSize( info.map, 0 );
+		ivec2 resolution = textureSize( envMapInfo.map, 0 );
 		float pdf = lum / totalSum;
 
 		return float( resolution.x * resolution.y ) * pdf * equirectDirectionPdf( direction );
@@ -5635,24 +5668,17 @@ bool bvhIntersectFogVolumeHit(
 
 	};
 
-	bool lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrigin, vec3 rayDirection, out LightRecord lightRec ) {
+	bool intersectLightAtIndex( sampler2D lights, vec3 rayOrigin, vec3 rayDirection, uint l, inout LightRecord lightRec ) {
 
 		bool didHit = false;
-		uint l;
-		for ( l = 0u; l < lightCount; l ++ ) {
-
-			Light light = readLightInfo( lights, l );
-
-			vec3 u = light.u;
-			vec3 v = light.v;
-
-			// check for backface
-			vec3 normal = normalize( cross( u, v ) );
-			if ( dot( normal, rayDirection ) < 0.0 ) {
+		Light light = readLightInfo( lights, l );
 
-				continue;
+		vec3 u = light.u;
+		vec3 v = light.v;
 
-			}
+		// check for backface
+		vec3 normal = normalize( cross( u, v ) );
+		if ( dot( normal, rayDirection ) > 0.0 ) {
 
 			u *= 1.0 / dot( u, u );
 			v *= 1.0 / dot( v, v );
@@ -5665,17 +5691,13 @@ bool bvhIntersectFogVolumeHit(
 				( light.type == CIRC_AREA_LIGHT_TYPE && intersectsCircle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) )
 			) {
 
-				if ( ! didHit || dist < lightRec.dist ) {
-
-					float cosTheta = dot( rayDirection, normal );
-					didHit = true;
-					lightRec.dist = dist;
-					lightRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
-					lightRec.emission = light.color * light.intensity;
-					lightRec.direction = rayDirection;
-					lightRec.type = light.type;
-
-				}
+				float cosTheta = dot( rayDirection, normal );
+				didHit = true;
+				lightRec.dist = dist;
+				lightRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
+				lightRec.emission = light.color * light.intensity;
+				lightRec.direction = rayDirection;
+				lightRec.type = light.type;
 
 			}
 
@@ -5687,11 +5709,6 @@ bool bvhIntersectFogVolumeHit(
 
 	LightRecord randomAreaLightSample( Light light, vec3 rayOrigin, vec2 ruv ) {
 
-		LightRecord lightRec;
-		lightRec.type = light.type;
-
-		lightRec.emission = light.color * light.intensity;
-
 		vec3 randomPos;
 		if( light.type == RECT_AREA_LIGHT_TYPE ) {
 
@@ -5712,12 +5729,17 @@ bool bvhIntersectFogVolumeHit(
 
 		vec3 toLight = randomPos - rayOrigin;
 		float lightDistSq = dot( toLight, toLight );
-		lightRec.dist = sqrt( lightDistSq );
+		float dist = sqrt( lightDistSq );
+		vec3 direction = toLight / dist;
+		vec3 lightNormal = normalize( cross( light.u, light.v ) );
 
-		vec3 direction = toLight / lightRec.dist;
+		LightRecord lightRec;
+		lightRec.type = light.type;
+		lightRec.emission = light.color * light.intensity;
+		lightRec.dist = dist;
 		lightRec.direction = direction;
 
-		vec3 lightNormal = normalize( cross( light.u, light.v ) );
+		// TODO: the denominator is potentially zero
 		lightRec.pdf = lightDistSq / ( light.area * dot( direction, lightNormal ) );
 
 		return lightRec;
@@ -5765,13 +5787,15 @@ bool bvhIntersectFogVolumeHit(
 
 	LightRecord randomLightSample( sampler2D lights, sampler2DArray iesProfiles, uint lightCount, vec3 rayOrigin, vec3 ruv ) {
 
+		LightRecord result;
+
 		// pick a random light
 		uint l = uint( ruv.x * float( lightCount ) );
 		Light light = readLightInfo( lights, l );
 
 		if ( light.type == SPOT_LIGHT_TYPE ) {
 
-			return randomSpotLightSample( light, iesProfiles, rayOrigin, ruv.yz );
+			result = randomSpotLightSample( light, iesProfiles, rayOrigin, ruv.yz );
 
 		} else if ( light.type == POINT_LIGHT_TYPE ) {
 
@@ -5791,7 +5815,7 @@ bool bvhIntersectFogVolumeHit(
 			rec.pdf = 1.0;
 			rec.emission = light.color * light.intensity * distanceFalloff;
 			rec.type = light.type;
-			return rec;
+			result = rec;
 
 		} else if ( light.type == DIR_LIGHT_TYPE ) {
 
@@ -5802,16 +5826,18 @@ bool bvhIntersectFogVolumeHit(
 			rec.emission = light.color * light.intensity;
 			rec.type = light.type;
 
-			return rec;
+			result = rec;
 
 		} else {
 
 			// sample the light
-			return randomAreaLightSample( light, rayOrigin, ruv.yz );
+			result = randomAreaLightSample( light, rayOrigin, ruv.yz );
 
 		}
 
-	}
+		return result;
+
+	}
 
 `;
 
@@ -5907,7 +5933,7 @@ bool bvhIntersectFogVolumeHit(
 	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
 	// falls in the bounds of the rectangle on that same plane.
 	// Plane intersection: https://lousodrome.net/blog/light/2020/07/03/intersection-of-a-ray-and-a-plane/
-	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, inout float dist ) {
 
 		float t = dot( center - rayOrigin, normal ) / dot( rayDirection, normal );
 
@@ -5938,7 +5964,7 @@ bool bvhIntersectFogVolumeHit(
 
 	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
 	// falls in the bounds of the circle on that same plane. See above URL for a description of the plane intersection algorithm.
-	bool intersectsCircle( vec3 position, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+	bool intersectsCircle( vec3 position, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, inout float dist ) {
 
 		float t = dot( position - rayOrigin, normal ) / dot( rayDirection, normal );
 
@@ -6118,32 +6144,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 */`
@@ -6200,28 +6232,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 );
@@ -6294,7 +6326,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;
 
@@ -6339,7 +6371,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 );
@@ -6370,11 +6402,14 @@ bool bvhIntersectFogVolumeHit(
 	// step through multiple surface hits and accumulate color attenuation based on transmissive surfaces
 	// returns true if a solid surface was hit
 	bool attenuateHit(
-		BVH bvh, RenderState state,
+		RenderState state,
 		Ray ray, float rayDist,
 		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;
@@ -6384,34 +6419,28 @@ bool bvhIntersectFogVolumeHit(
 
 		// hit results
 		SurfaceHit surfaceHit;
-		LightRecord lightRec;
 
 		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 ++ ) {
 
-			int hitType = traceScene(
-				ray, bvh, lights, fogMaterial,
-				surfaceHit, lightRec
-			);
-
-			if ( hitType == FOG_HIT ) {
+			sobolBounceIndex ++;
 
-				return true;
+			int hitType = traceScene( ray, fogMaterial, surfaceHit );
 
-			} else if ( hitType == LIGHT_HIT ) {
+			if ( hitType == FOG_HIT ) {
 
-				float totalDist = distance( startPoint, ray.origin + ray.direction * lightRec.dist );
-				return totalDist < rayDist - max( totalDist, rayDist ) * 1e-4;
+				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;
 
 				}
 
@@ -6493,7 +6522,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
 
@@ -6501,11 +6530,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;
 
 				}
 
@@ -6531,13 +6561,16 @@ bool bvhIntersectFogVolumeHit(
 
 			} else {
 
-				return false;
+				result = false;
+				break;
 
 			}
 
 		}
 
-		return true;
+		// reset the bounce index
+		sobolBounceIndex = originalBounceIndex;
+		return result;
 
 	}
 
@@ -6550,22 +6583,26 @@ bool bvhIntersectFogVolumeHit(
 	#define LIGHT_HIT 2
 	#define FOG_HIT 3
 
+	// Passing the global variable 'lights' into this function caused shader program errors.
+	// So global variables like 'lights' and 'bvh' were moved out of the function parameters.
+	// For more information, refer to: https://github.com/gkjohnson/three-gpu-pathtracer/pull/457
 	int traceScene(
 
-		Ray ray, BVH bvh, LightsInfo lights, Material fogMaterial,
-		out SurfaceHit surfaceHit, out LightRecord lightRec
+		Ray ray, Material fogMaterial, inout SurfaceHit surfaceHit
 
 	) {
 
+		int result = NO_HIT;
 		bool hit = bvhIntersectFirstHit( bvh, ray.origin, ray.direction, surfaceHit.faceIndices, surfaceHit.faceNormal, surfaceHit.barycoord, surfaceHit.side, surfaceHit.dist );
-		bool lightHit = lightsClosestHit( lights.tex, lights.count, ray.origin, ray.direction, lightRec );
 
 		#if FEATURE_FOG
 
 		if ( fogMaterial.fogVolume ) {
 
-			float particleDist = intersectFogVolume( fogMaterial, sobol( 1 ) );
-			if ( particleDist + 1e-4 < surfaceHit.dist && ( particleDist + 1e-4 < lightRec.dist || ! lightHit ) ) {
+			// offset the distance so we don't run into issues with particles on the same surface
+			// as other objects
+			float particleDist = intersectFogVolume( fogMaterial, rand( 1 ) );
+			if ( particleDist + RAY_OFFSET < surfaceHit.dist ) {
 
 				surfaceHit.side = 1.0;
 				surfaceHit.faceNormal = normalize( - ray.direction );
@@ -6578,19 +6615,13 @@ bool bvhIntersectFogVolumeHit(
 
 		#endif
 
-		if ( lightHit && ( lightRec.dist < surfaceHit.dist || ! hit ) ) {
-
-			return LIGHT_HIT;
-
-		}
-
 		if ( hit ) {
 
-			return SURFACE_HIT;
+			result = SURFACE_HIT;
 
 		}
 
-		return NO_HIT;
+		return result;
 
 	}
 
@@ -6603,7 +6634,7 @@ bool bvhIntersectFogVolumeHit(
 	int getSurfaceRecord(
 		Material material, SurfaceHit surfaceHit, sampler2DArray attributesArray,
 		float accumulatedRoughness,
-		out SurfaceRecord surf
+		inout SurfaceRecord surf
 	) {
 
 		if ( material.fogVolume ) {
@@ -6633,6 +6664,7 @@ bool bvhIntersectFogVolumeHit(
 
 			vec3 uvPrime = material.mapTransform * vec3( uv, 1 );
 			albedo *= texture2D( textures, vec3( uvPrime.xy, material.map ) );
+
 		}
 
 		if ( material.vertexColors ) {
@@ -6664,7 +6696,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;
@@ -6923,11 +6955,13 @@ bool bvhIntersectFogVolumeHit(
 
 	vec3 directLightContribution( vec3 worldWo, SurfaceRecord surf, RenderState state, vec3 rayOrigin ) {
 
+		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 ) {
@@ -6944,7 +6978,7 @@ bool bvhIntersectFogVolumeHit(
 			if (
 				lightRec.pdf > 0.0 &&
 				isDirectionValid( lightRec.direction, surf.normal, surf.faceNormal ) &&
-				! attenuateHit( bvh, state, lightRay, lightRec.dist, attenuatedColor )
+				! attenuateHit( state, lightRay, lightRec.dist, attenuatedColor )
 			) {
 
 				// get the material pdf
@@ -6956,7 +6990,7 @@ bool bvhIntersectFogVolumeHit(
 					// weight the direct light contribution
 					float lightPdf = lightRec.pdf / lightsDenom;
 					float misWeight = lightRec.type == SPOT_LIGHT_TYPE || lightRec.type == DIR_LIGHT_TYPE || lightRec.type == POINT_LIGHT_TYPE ? 1.0 : misHeuristic( lightPdf, lightMaterialPdf );
-					return attenuatedColor * lightRec.emission * state.throughputColor * sampleColor * misWeight / lightPdf;
+					result = attenuatedColor * lightRec.emission * state.throughputColor * sampleColor * misWeight / lightPdf;
 
 				}
 
@@ -6966,7 +7000,7 @@ bool bvhIntersectFogVolumeHit(
 
 			// find a sample in the environment map to include in the contribution
 			vec3 envColor, envDirection;
-			float envPdf = sampleEquirectProbability( envMapInfo, 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
@@ -6987,7 +7021,7 @@ bool bvhIntersectFogVolumeHit(
 			if (
 				envPdf > 0.0 &&
 				isDirectionValid( envDirection, surf.normal, surf.faceNormal ) &&
-				! attenuateHit( bvh, state, envRay, INFINITY, attenuatedColor )
+				! attenuateHit( state, envRay, INFINITY, attenuatedColor )
 			) {
 
 				// get the material pdf
@@ -6999,7 +7033,7 @@ bool bvhIntersectFogVolumeHit(
 					// weight the direct light contribution
 					envPdf /= lightsDenom;
 					float misWeight = misHeuristic( envPdf, envMaterialPdf );
-					return attenuatedColor * environmentIntensity * envColor * state.throughputColor * sampleColor * misWeight / envPdf;
+					result = attenuatedColor * environmentIntensity * envColor * state.throughputColor * sampleColor * misWeight / envPdf;
 
 				}
 
@@ -7007,12 +7041,675 @@ bool bvhIntersectFogVolumeHit(
 
 		}
 
-		return vec3( 0.0 );
+		// Function changed to have a single return statement to potentially help with crashes on Mac OS.
+		// See issue #470
+		return result;
+
+	}
+
+`;
+
+	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() {
@@ -7036,6 +7733,12 @@ bool bvhIntersectFogVolumeHit(
 					FEATURE_DOF: 1,
 					FEATURE_BACKGROUND_MAP: 0,
 					FEATURE_FOG: 1,
+
+					// 0 = PCG
+					// 1 = Sobol
+					// 2 = Stratified List
+					RANDOM_TYPE: 2,
+
 					// 0 = Perspective
 					// 1 = Orthographic
 					// 2 = Equirectangular
@@ -7077,6 +7780,8 @@ bool bvhIntersectFogVolumeHit(
 
 					backgroundAlpha: { value: 1.0 },
 					sobolTexture: { value: null },
+					stratifiedTexture: { value: new StratifiedSamplesTexture() },
+					stratifiedOffsetTexture: { value: new BlueNoiseTexture( 64, 1 ) },
 				},
 
 				vertexShader: /* glsl */`
@@ -7105,13 +7810,48 @@ bool bvhIntersectFogVolumeHit(
 				#include <common>
 
 				// bvh intersection
-				${ threeMeshBvh.shaderStructs }
-				${ threeMeshBvh.shaderIntersectFunction }
+				${ threeMeshBvh.BVHShaderGLSL.common_functions }
+				${ threeMeshBvh.BVHShaderGLSL.bvh_struct_definitions }
+				${ threeMeshBvh.BVHShaderGLSL.bvh_ray_functions }
+
+				// uniform structs
+				${ cameraStructGLSL }
+				${ lightsStructGLSL }
+				${ equirectStructGLSL }
+				${ materialStructGLSL }
 
 				// random
-				${ pcgGLSL }
-				${ sobolCommonGLSL }
-				${ sobolSamplingGLSL }
+				#if RANDOM_TYPE == 2 	// Stratified List
+
+					${ stratifiedTextureGLSL }
+
+				#elif RANDOM_TYPE == 1 	// Sobol
+
+					${ pcgGLSL }
+					${ sobolCommonGLSL }
+					${ sobolSamplingGLSL }
+
+					#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;
+
+					#define rand(v) pcgRand()
+					#define rand2(v) pcgRand2()
+					#define rand3(v) pcgRand3()
+					#define rand4(v) pcgRand4()
+
+				#endif
 
 				// common
 				${ arraySamplerTexelFetchGLSL }
@@ -7120,20 +7860,6 @@ bool bvhIntersectFogVolumeHit(
 				${ mathGLSL }
 				${ intersectShapesGLSL }
 
-				// uniform structs
-				${ cameraStructGLSL }
-				${ lightsStructGLSL }
-				${ equirectStructGLSL }
-				${ materialStructGLSL }
-				${ fogMaterialBvhGLSL }
-
-				// sampling
-				${ shapeSamplingGLSL }
-				${ bsdfSamplingGLSL }
-				${ equirectSamplingGLSL }
-				${ lightSamplingGLSL }
-				${ fogGLSL }
-
 				// environment
 				uniform EquirectHdrInfo envMapInfo;
 				uniform mat4 environmentRotation;
@@ -7185,6 +7911,14 @@ bool bvhIntersectFogVolumeHit(
 				mat3 invEnvRotation3x3;
 				float lightsDenom;
 
+				// sampling
+				${ fogMaterialBvhGLSL }
+				${ shapeSamplingGLSL }
+				${ bsdfSamplingGLSL }
+				${ equirectSamplingGLSL }
+				${ lightSamplingGLSL }
+				${ fogGLSL }
+
 				float applyFilteredGlossy( float roughness, float accumulatedRoughness ) {
 
 					return clamp(
@@ -7224,7 +7958,7 @@ bool bvhIntersectFogVolumeHit(
 
 					// init
 					rng_initialize( gl_FragCoord.xy, seed );
-					sobolPixelIndex = ( uint( gl_FragCoord.x ) << 16 ) |  uint( gl_FragCoord.y );
+					sobolPixelIndex = ( uint( gl_FragCoord.x ) << 16 ) | uint( gl_FragCoord.y );
 					sobolPathIndex = uint( seed );
 
 					// get camera ray
@@ -7240,7 +7974,6 @@ bool bvhIntersectFogVolumeHit(
 
 					// surface results
 					SurfaceHit surfaceHit;
-					LightRecord lightRec;
 					ScatterRecord scatterRec;
 
 					// path tracing state
@@ -7249,7 +7982,7 @@ bool bvhIntersectFogVolumeHit(
 					#if FEATURE_FOG
 
 					state.fogMaterial.fogVolume = bvhIntersectFogVolumeHit(
-						bvh, ray.origin, - ray.direction,
+						ray.origin, - ray.direction,
 						materialIndexAttribute, materials,
 						state.fogMaterial
 					);
@@ -7264,48 +7997,46 @@ bool bvhIntersectFogVolumeHit(
 						state.traversals = bounces - i;
 						state.firstRay = i == 0 && state.transmissiveTraversals == transmissiveBounces;
 
-						int hitType = traceScene(
-							ray, bvh, lights, state.fogMaterial,
-							surfaceHit, lightRec
-						);
+						int hitType = traceScene( ray, state.fogMaterial, surfaceHit );
 
-						if ( hitType == LIGHT_HIT ) {
+						// check if we intersect any lights and accumulate the light contribution
+						// TODO: we can add support for light surface rendering in the else condition if we
+						// add the ability to toggle visibility of the the light
+						if ( ! state.firstRay && ! state.transmissiveRay ) {
 
-							if ( state.firstRay || state.transmissiveRay ) {
+							LightRecord lightRec;
+							float lightDist = hitType == NO_HIT ? INFINITY : surfaceHit.dist;
+							for ( uint i = 0u; i < lights.count; i ++ ) {
 
-								gl_FragColor.rgb += lightRec.emission * state.throughputColor;
+								if (
+									intersectLightAtIndex( lights.tex, ray.origin, ray.direction, i, lightRec ) &&
+									lightRec.dist < lightDist
+								) {
 
-							} else {
-
-								#if FEATURE_MIS
-
-								// NOTE: we skip MIS for punctual lights since they are not supported in forward PT case
-								if ( lightRec.type == SPOT_LIGHT_TYPE || lightRec.type == DIR_LIGHT_TYPE || lightRec.type == POINT_LIGHT_TYPE ) {
-
-									gl_FragColor.rgb += lightRec.emission * state.throughputColor;
-
-								} else {
+									#if FEATURE_MIS
 
 									// weight the contribution
+									// NOTE: Only area lights are supported for forward sampling and can be hit
 									float misWeight = misHeuristic( scatterRec.pdf, lightRec.pdf / lightsDenom );
 									gl_FragColor.rgb += lightRec.emission * state.throughputColor * misWeight;
 
-								}
+									#else
 
-								#else
+									gl_FragColor.rgb += lightRec.emission * state.throughputColor;
 
-								gl_FragColor.rgb += lightRec.emission * state.throughputColor;
+									#endif
 
-								#endif
+								}
 
 							}
-							break;
 
-						} else if ( hitType == NO_HIT ) {
+						}
+
+						if ( hitType == NO_HIT ) {
 
 							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 {
@@ -7314,7 +8045,7 @@ bool bvhIntersectFogVolumeHit(
 
 								// get the PDF of the hit envmap point
 								vec3 envColor;
-								float envPdf = sampleEquirect( envMapInfo, envRotation3x3 * ray.direction, envColor );
+								float envPdf = sampleEquirect( envRotation3x3 * ray.direction, envColor );
 								envPdf /= lightsDenom;
 
 								// and weight the contribution
@@ -7396,7 +8127,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 );
@@ -7466,7 +8197,7 @@ bool bvhIntersectFogVolumeHit(
 						rrProb = sqrt( rrProb );
 						rrProb = max( rrProb, depthProb );
 						rrProb = min( rrProb, 1.0 );
-						if ( sobol( 8 ) > rrProb ) {
+						if ( rand( 8 ) > rrProb ) {
 
 							break;
 
@@ -7897,10 +8628,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 });